@fragno-dev/db 0.1.15 → 0.2.0

package/dist/sql-driver/sql.js

@@ -0,0 +1,50 @@
+import { sql } from "kysely";
+
+//#region src/sql-driver/sql.ts
+/**
+* Wrapper around Kysely's RawBuilder that provides a compile() method with a dialect parameter.
+*/
+var RawBuilder = class {
+	#kyselyBuilder;
+	constructor(kyselyBuilder) {
+		this.#kyselyBuilder = kyselyBuilder;
+	}
+	/**
+	* Compiles the SQL query using the provided Kysely dialect.
+	* Creates a minimal query executor with the dialect's adapter and query compiler.
+	*
+	* @param dialect - Kysely dialect (e.g., SqliteDialect, PostgresDialect, MysqlDialect)
+	* @returns Compiled query with SQL string and parameters
+	*/
+	compile(dialect) {
+		const queryCompiler = dialect.createQueryCompiler();
+		return this.#kyselyBuilder.compile({ getExecutor() {
+			return {
+				transformQuery(node, _queryId) {
+					return node;
+				},
+				compileQuery(node, queryId) {
+					return queryCompiler.compileQuery(node, queryId);
+				}
+			};
+		} });
+	}
+};
+/**
+* Tagged template function for building SQL queries with parameters.
+* Wraps Kysely's sql function to provide a compile() method without arguments.
+*
+* @example
+* ```ts
+* const userId = 123;
+* const query = sql`SELECT * FROM users WHERE id = ${userId}`;
+* const compiled = query.compile();
+* ```
+*/
+function sql$1(strings, ...values) {
+	return new RawBuilder(sql(strings, ...values));
+}
+
+//#endregion
+export { sql$1 as sql };
+//# sourceMappingURL=sql.js.map

package/dist/sql-driver/sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.js","names":["#kyselyBuilder","sql","kyselySql"],"sources":["../../src/sql-driver/sql.ts"],"sourcesContent":["import type { CompiledQuery, Dialect } from \"./sql-driver\";\nimport {\n  sql as kyselySql,\n  type QueryExecutor,\n  type CompiledQuery as KyselyCompiledQuery,\n} from \"kysely\";\n\n/**\n * Wrapper around Kysely's RawBuilder that provides a compile() method with a dialect parameter.\n */\nexport class RawBuilder {\n  #kyselyBuilder: ReturnType<typeof kyselySql>;\n\n  constructor(kyselyBuilder: ReturnType<typeof kyselySql>) {\n    this.#kyselyBuilder = kyselyBuilder;\n  }\n\n  /**\n   * Compiles the SQL query using the provided Kysely dialect.\n   * Creates a minimal query executor with the dialect's adapter and query compiler.\n   *\n   * @param dialect - Kysely dialect (e.g., SqliteDialect, PostgresDialect, MysqlDialect)\n   * @returns Compiled query with SQL string and parameters\n   */\n  compile(dialect: Dialect): CompiledQuery {\n    const queryCompiler = dialect.createQueryCompiler();\n\n    return this.#kyselyBuilder.compile({\n      getExecutor(): QueryExecutor {\n        return {\n          transformQuery(node, _queryId) {\n            return node;\n          },\n          compileQuery(node, queryId) {\n            return queryCompiler.compileQuery(node, queryId) as KyselyCompiledQuery;\n          },\n        } as QueryExecutor;\n      },\n    });\n  }\n}\n\n/**\n * Tagged template function for building SQL queries with parameters.\n * Wraps Kysely's sql function to provide a compile() method without arguments.\n *\n * @example\n * ```ts\n * const userId = 123;\n * const query = sql`SELECT * FROM users WHERE id = ${userId}`;\n * const compiled = query.compile();\n * ```\n */\nexport function sql(strings: TemplateStringsArray, ...values: unknown[]): RawBuilder {\n  const kyselyBuilder = kyselySql(strings, ...values);\n  return new RawBuilder(kyselyBuilder);\n}\n"],"mappings":";;;;;;AAUA,IAAa,aAAb,MAAwB;CACtB;CAEA,YAAY,eAA6C;AACvD,QAAKA,gBAAiB;;;;;;;;;CAUxB,QAAQ,SAAiC;EACvC,MAAM,gBAAgB,QAAQ,qBAAqB;AAEnD,SAAO,MAAKA,cAAe,QAAQ,EACjC,cAA6B;AAC3B,UAAO;IACL,eAAe,MAAM,UAAU;AAC7B,YAAO;;IAET,aAAa,MAAM,SAAS;AAC1B,YAAO,cAAc,aAAa,MAAM,QAAQ;;IAEnD;KAEJ,CAAC;;;;;;;;;;;;;;AAeN,SAAgBC,MAAI,SAA+B,GAAG,QAA+B;AAEnF,QAAO,IAAI,WADWC,IAAU,SAAS,GAAG,OAAO,CACf"}

package/dist/with-database.d.ts

@@ -1,6 +1,8 @@
 import { AnySchema } from "./schema/create.js";
 import { DatabaseFragmentDefinitionBuilder, DatabaseHandlerContext, DatabaseServiceContext, ImplicitDatabaseDependencies } from "./db-fragment-definition-builder.js";
-import { FragmentDefinitionBuilder, FragnoPublicConfig, RequestThisContext } from "@fragno-dev/core";
+import { InternalFragmentInstance } from "./fragments/internal-fragment.js";
+import { HooksMap } from "./hooks/hooks.js";
+import { AnyFragnoInstantiatedFragment, FragmentDefinitionBuilder, FragnoPublicConfig, RequestThisContext } from "@fragno-dev/core";
 
 //#region src/with-database.d.ts
 
@@ -22,7 +24,9 @@ import { FragmentDefinitionBuilder, FragnoPublicConfig, RequestThisContext } fro
  *   .build();
  * ```
  */
-declare function withDatabase<TSchema extends AnySchema>(schema: TSchema, namespace?: string): <TConfig, TDeps, TBaseServices, TServices, TServiceDeps, TPrivateServices, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage>(builder: FragmentDefinitionBuilder<TConfig, FragnoPublicConfig, TDeps, TBaseServices, TServices, TServiceDeps, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage>) => DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps & ImplicitDatabaseDependencies<TSchema>, TBaseServices, TServices, TServiceDeps, TPrivateServices, DatabaseServiceContext, DatabaseHandlerContext>;
+declare function withDatabase<TSchema extends AnySchema>(schema: TSchema, namespace?: string): <TConfig, TDeps, TBaseServices, TServices, TServiceDeps, TPrivateServices, TServiceThisContext extends RequestThisContext, THandlerThisContext extends RequestThisContext, TRequestStorage, TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment>>(builder: FragmentDefinitionBuilder<TConfig, FragnoPublicConfig, TDeps, TBaseServices, TServices, TServiceDeps, TPrivateServices, TServiceThisContext, THandlerThisContext, TRequestStorage, TLinkedFragments>) => DatabaseFragmentDefinitionBuilder<TSchema, TConfig, TDeps & ImplicitDatabaseDependencies<TSchema>, TBaseServices, TServices, TServiceDeps, TPrivateServices, HooksMap, DatabaseServiceContext<HooksMap>, DatabaseHandlerContext, TLinkedFragments & {
+  _fragno_internal: InternalFragmentInstance;
+}>;
 //#endregion
 export { withDatabase };
 //# sourceMappingURL=with-database.d.ts.map

package/dist/with-database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"with-database.d.ts","names":[],"sources":["../src/with-database.ts"],"sourcesContent":[],"mappings":";;;;;;;AA+BA;;;;;;;;;;;;;;;;;AA4BE,iBA5Bc,YA4Bd,CAAA,gBA5B2C,SA4B3C,CAAA,CAAA,MAAA,EA3BQ,OA2BR,EAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EAAA,CAAA,OAAA,EAAA,KAAA,EAAA,aAAA,EAAA,SAAA,EAAA,YAAA,EAAA,gBAAA,EAAA,4BAlB4B,kBAkB5B,EAAA,4BAjB4B,kBAiB5B,EAAA,eAAA,CAAA,CAAA,OAAA,EAdS,yBAcT,CAbE,OAaF,EAZE,kBAYF,EAXE,KAWF,EAVE,aAUF,EATE,SASF,EARE,YAQF,EAPE,gBAOF,EANE,mBAMF,EALE,mBAKF,EAJE,eAIF,CAAA,EAAA,GAFG,iCAEH,CADA,OACA,EAAA,OAAA,EACA,KADA,GACQ,4BADR,CACqC,OADrC,CAAA,EAEA,aAFA,EAGA,SAHA,EAIA,YAJA,EAKA,gBALA,EAMA,sBANA,EAOA,sBAPA,CAAA"}
+{"version":3,"file":"with-database.d.ts","names":[],"sources":["../src/with-database.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAoCA;;;;;;;;;;;;;;;;;AA0BI,iBA1BY,YA0BZ,CAAA,gBA1ByC,SA0BzC,CAAA,CAAA,MAAA,EAzBM,OAyBN,EAAA,SAAA,CAAA,EAAA,MAAA,CAAA,EAAA,CAAA,OAAA,EAAA,KAAA,EAAA,aAAA,EAAA,SAAA,EAAA,YAAA,EAAA,gBAAA,EAAA,4BAhB0B,kBAgB1B,EAAA,4BAf0B,kBAe1B,EAAA,eAAA,EAAA,yBAbuB,MAavB,CAAA,MAAA,EAbsC,6BAatC,CAAA,CAAA,CAAA,OAAA,EAXO,yBAWP,CAVA,OAUA,EATA,kBASA,EARA,KAQA,EAPA,aAOA,EANA,SAMA,EALA,YAKA,EAJA,gBAIA,EAHA,mBAGA,EAFA,mBAEA,EADA,eACA,EAAA,gBAAA,CAAA,EAAA,GAEC,iCAFD,CAGF,OAHE,EAIF,OAJE,EAKF,KALE,GAKM,4BALN,CAKmC,OALnC,CAAA,EAMF,aANE,EAOF,SAPE,EAQF,YARE,EASF,gBATE,EAUF,QAVE,EAWF,sBAXE,CAWqB,QAXrB,CAAA,EAYF,sBAZE,EAaF,gBAbE,GAAA;EAXO,gBAAA,EAwB8B,wBAxB9B;CAcT,CAAA"}

package/dist/with-database.js

@@ -23,7 +23,7 @@ import { internalFragmentDef } from "./fragments/internal-fragment.js";
 */
 function withDatabase(schema, namespace) {
 	return (builder) => {
-		return new DatabaseFragmentDefinitionBuilder(builder.name === "$fragno-internal-fragment" ? builder : builder.withLinkedFragment("_fragno_internal", ({ config, options }) => {
+		return new DatabaseFragmentDefinitionBuilder(builder.withLinkedFragment("_fragno_internal", ({ config, options }) => {
 			return instantiate(internalFragmentDef).withConfig(config).withOptions(options).build();
 		}), schema, namespace);
 	};

package/dist/with-database.js.map

@@ -1 +1 @@
-{"version":3,"file":"with-database.js","names":[],"sources":["../src/with-database.ts"],"sourcesContent":["import type { AnySchema } from \"./schema/create\";\nimport type { RequestThisContext, FragnoPublicConfig } from \"@fragno-dev/core\";\nimport { FragmentDefinitionBuilder, instantiate } from \"@fragno-dev/core\";\nimport {\n  DatabaseFragmentDefinitionBuilder,\n  type DatabaseServiceContext,\n  type DatabaseHandlerContext,\n  type ImplicitDatabaseDependencies,\n  type FragnoPublicConfigWithDatabase,\n  type DatabaseRequestStorage,\n} from \"./db-fragment-definition-builder\";\nimport { internalFragmentDef } from \"./fragments/internal-fragment\";\n\n/**\n * Helper to add database support to a fragment builder.\n * Automatically links the internal fragment and adds ImplicitDatabaseDependencies to the TDeps type.\n *\n * @example\n * ```typescript\n * // With .extend() - recommended\n * const def = defineFragment(\"my-frag\")\n *   .extend(withDatabase(mySchema))\n *   .withDependencies(...)\n *   .build();\n *\n * // Or as a function wrapper\n * const def = withDatabase(mySchema)(defineFragment(\"my-frag\"))\n *   .withDependencies(...)\n *   .build();\n * ```\n */\nexport function withDatabase<TSchema extends AnySchema>(\n  schema: TSchema,\n  namespace?: string,\n): <\n  TConfig,\n  TDeps,\n  TBaseServices,\n  TServices,\n  TServiceDeps,\n  TPrivateServices,\n  TServiceThisContext extends RequestThisContext,\n  THandlerThisContext extends RequestThisContext,\n  TRequestStorage,\n>(\n  builder: FragmentDefinitionBuilder<\n    TConfig,\n    FragnoPublicConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage\n  >,\n) => DatabaseFragmentDefinitionBuilder<\n  TSchema,\n  TConfig,\n  TDeps & ImplicitDatabaseDependencies<TSchema>,\n  TBaseServices,\n  TServices,\n  TServiceDeps,\n  TPrivateServices,\n  DatabaseServiceContext,\n  DatabaseHandlerContext\n> {\n  return <\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext extends RequestThisContext,\n    THandlerThisContext extends RequestThisContext,\n    TRequestStorage,\n  >(\n    builder: FragmentDefinitionBuilder<\n      TConfig,\n      FragnoPublicConfig,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage\n    >,\n  ) => {\n    // Link the internal fragment to all database fragments (except the internal fragment itself)\n    // No circular dependency: internal-fragment.ts uses DatabaseFragmentDefinitionBuilder directly\n    const isInternalFragment = builder.name === \"$fragno-internal-fragment\";\n    const builderWithInternal = isInternalFragment\n      ? builder\n      : builder.withLinkedFragment(\"_fragno_internal\", ({ config, options }) => {\n          // Cast is safe: by the time this callback is invoked during fragment instantiation,\n          // the options will be FragnoPublicConfigWithDatabase (enforced by DatabaseFragmentDefinitionBuilder)\n          return instantiate(internalFragmentDef)\n            .withConfig(config as {})\n            .withOptions(options as FragnoPublicConfigWithDatabase)\n            .build();\n        });\n\n    // Cast is safe: we're creating a DatabaseFragmentDefinitionBuilder which internally uses\n    // FragnoPublicConfigWithDatabase, but the input builder uses FragnoPublicConfig.\n    // The database builder's build() method will enforce FragnoPublicConfigWithDatabase at the end.\n    // We also add ImplicitDatabaseDependencies to TDeps so they're available in service constructors.\n    // Note: We discard TRequestStorage here because database fragments manage their own storage (DatabaseRequestStorage).\n    // We set TServiceThisContext to DatabaseServiceContext (restricted) and THandlerThisContext to DatabaseHandlerContext (full).\n    return new DatabaseFragmentDefinitionBuilder<\n      TSchema,\n      TConfig,\n      TDeps & ImplicitDatabaseDependencies<TSchema>,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      DatabaseServiceContext,\n      DatabaseHandlerContext\n    >(\n      builderWithInternal as unknown as FragmentDefinitionBuilder<\n        TConfig,\n        FragnoPublicConfigWithDatabase,\n        TDeps & ImplicitDatabaseDependencies<TSchema>,\n        TBaseServices,\n        TServices,\n        TServiceDeps,\n        TPrivateServices,\n        DatabaseServiceContext,\n        DatabaseHandlerContext,\n        DatabaseRequestStorage\n      >,\n      schema,\n      namespace,\n    );\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,aACd,QACA,WAkCA;AACA,SAWE,YAYG;AAqBH,SAAO,IAAI,kCAlBgB,QAAQ,SAAS,8BAExC,UACA,QAAQ,mBAAmB,qBAAqB,EAAE,QAAQ,cAAc;AAGtE,UAAO,YAAY,oBAAoB,CACpC,WAAW,OAAa,CACxB,YAAY,QAA0C,CACtD,OAAO;IACV,EA+BJ,QACA,UACD"}
+{"version":3,"file":"with-database.js","names":[],"sources":["../src/with-database.ts"],"sourcesContent":["import type { AnySchema } from \"./schema/create\";\nimport type {\n  RequestThisContext,\n  FragnoPublicConfig,\n  AnyFragnoInstantiatedFragment,\n} from \"@fragno-dev/core\";\nimport { FragmentDefinitionBuilder, instantiate } from \"@fragno-dev/core\";\nimport {\n  DatabaseFragmentDefinitionBuilder,\n  type DatabaseServiceContext,\n  type DatabaseHandlerContext,\n  type ImplicitDatabaseDependencies,\n  type FragnoPublicConfigWithDatabase,\n  type DatabaseRequestStorage,\n} from \"./db-fragment-definition-builder\";\nimport { internalFragmentDef, type InternalFragmentInstance } from \"./fragments/internal-fragment\";\nimport type { HooksMap } from \"./hooks/hooks\";\n\n/**\n * Helper to add database support to a fragment builder.\n * Automatically links the internal fragment and adds ImplicitDatabaseDependencies to the TDeps type.\n *\n * @example\n * ```typescript\n * // With .extend() - recommended\n * const def = defineFragment(\"my-frag\")\n *   .extend(withDatabase(mySchema))\n *   .withDependencies(...)\n *   .build();\n *\n * // Or as a function wrapper\n * const def = withDatabase(mySchema)(defineFragment(\"my-frag\"))\n *   .withDependencies(...)\n *   .build();\n * ```\n */\nexport function withDatabase<TSchema extends AnySchema>(\n  schema: TSchema,\n  namespace?: string,\n): <\n  TConfig,\n  TDeps,\n  TBaseServices,\n  TServices,\n  TServiceDeps,\n  TPrivateServices,\n  TServiceThisContext extends RequestThisContext,\n  THandlerThisContext extends RequestThisContext,\n  TRequestStorage,\n  TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment>,\n>(\n  builder: FragmentDefinitionBuilder<\n    TConfig,\n    FragnoPublicConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext,\n    THandlerThisContext,\n    TRequestStorage,\n    TLinkedFragments\n  >,\n) => DatabaseFragmentDefinitionBuilder<\n  TSchema,\n  TConfig,\n  TDeps & ImplicitDatabaseDependencies<TSchema>,\n  TBaseServices,\n  TServices,\n  TServiceDeps,\n  TPrivateServices,\n  HooksMap,\n  DatabaseServiceContext<HooksMap>,\n  DatabaseHandlerContext,\n  TLinkedFragments & { _fragno_internal: InternalFragmentInstance }\n> {\n  return <\n    TConfig,\n    TDeps,\n    TBaseServices,\n    TServices,\n    TServiceDeps,\n    TPrivateServices,\n    TServiceThisContext extends RequestThisContext,\n    THandlerThisContext extends RequestThisContext,\n    TRequestStorage,\n    TLinkedFragments extends Record<string, AnyFragnoInstantiatedFragment>,\n  >(\n    builder: FragmentDefinitionBuilder<\n      TConfig,\n      FragnoPublicConfig,\n      TDeps,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      TServiceThisContext,\n      THandlerThisContext,\n      TRequestStorage,\n      TLinkedFragments\n    >,\n  ) => {\n    const builderWithInternal = builder.withLinkedFragment(\n      \"_fragno_internal\",\n      ({ config, options }) => {\n        // Cast is safe: by the time this callback is invoked during fragment instantiation,\n        // the options will be FragnoPublicConfigWithDatabase (enforced by DatabaseFragmentDefinitionBuilder)\n        return instantiate(internalFragmentDef)\n          .withConfig(config as {})\n          .withOptions(options as FragnoPublicConfigWithDatabase)\n          .build();\n      },\n    );\n\n    // Cast is safe: we're creating a DatabaseFragmentDefinitionBuilder which internally uses\n    // FragnoPublicConfigWithDatabase, but the input builder uses FragnoPublicConfig.\n    // The database builder's build() method will enforce FragnoPublicConfigWithDatabase at the end.\n    // We also add ImplicitDatabaseDependencies to TDeps so they're available in service constructors.\n    // Note: We discard TRequestStorage here because database fragments manage their own storage (DatabaseRequestStorage).\n    // We set TServiceThisContext to DatabaseServiceContext (restricted) and THandlerThisContext to DatabaseHandlerContext (full).\n    return new DatabaseFragmentDefinitionBuilder<\n      TSchema,\n      TConfig,\n      TDeps & ImplicitDatabaseDependencies<TSchema>,\n      TBaseServices,\n      TServices,\n      TServiceDeps,\n      TPrivateServices,\n      {}, // Start with empty hooks, provideHooks() will update this\n      DatabaseServiceContext<{}>,\n      DatabaseHandlerContext,\n      TLinkedFragments & { _fragno_internal: InternalFragmentInstance }\n    >(\n      builderWithInternal as unknown as FragmentDefinitionBuilder<\n        TConfig,\n        FragnoPublicConfigWithDatabase,\n        TDeps & ImplicitDatabaseDependencies<TSchema>,\n        TBaseServices,\n        TServices,\n        TServiceDeps,\n        TPrivateServices,\n        DatabaseServiceContext<{}>,\n        DatabaseHandlerContext,\n        DatabaseRequestStorage,\n        TLinkedFragments & { _fragno_internal: InternalFragmentInstance }\n      >,\n      schema,\n      namespace,\n    );\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,aACd,QACA,WAsCA;AACA,SAYE,YAaG;AAmBH,SAAO,IAAI,kCAlBiB,QAAQ,mBAClC,qBACC,EAAE,QAAQ,cAAc;AAGvB,UAAO,YAAY,oBAAoB,CACpC,WAAW,OAAa,CACxB,YAAY,QAA0C,CACtD,OAAO;IAEb,EAkCC,QACA,UACD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fragno-dev/db",
-  "version": "0.1.15",
+  "version": "0.2.0",
   "type": "module",
   "exports": {
     ".": {
@@ -18,10 +18,30 @@
       "types": "./dist/schema/create.d.ts",
       "default": "./dist/schema/create.js"
     },
+    "./drivers": {
+      "development": "./src/adapters/generic-sql/driver-config.ts",
+      "types": "./dist/adapters/generic-sql/driver-config.d.ts",
+      "default": "./dist/adapters/generic-sql/driver-config.js"
+    },
+    "./sql-driver": {
+      "development": "./src/sql-driver/sql-driver.ts",
+      "types": "./dist/sql-driver/sql-driver.d.ts",
+      "default": "./dist/sql-driver/sql-driver.js"
+    },
+    "./dialects": {
+      "development": "./src/sql-driver/dialects/dialects.ts",
+      "types": "./dist/sql-driver/dialects/dialects.d.ts",
+      "default": "./dist/sql-driver/dialects/dialects.js"
+    },
+    "./dialects/durable-object": {
+      "development": "./src/sql-driver/dialects/durable-object-dialect.ts",
+      "types": "./dist/sql-driver/dialects/durable-object-dialect.d.ts",
+      "default": "./dist/sql-driver/dialects/durable-object-dialect.js"
+    },
     "./query": {
-      "development": "./src/query/query.ts",
-      "types": "./dist/query/query.d.ts",
-      "default": "./dist/query/query.js"
+      "development": "./src/query/simple-query-interface.ts",
+      "types": "./dist/query/simple-query-interface.d.ts",
+      "default": "./dist/query/simple-query-interface.js"
     },
     "./adapters": {
       "development": "./src/adapters/adapters.ts",
@@ -43,10 +63,15 @@
       "types": "./dist/adapters/drizzle/generate.d.ts",
       "default": "./dist/adapters/drizzle/generate.js"
     },
+    "./adapters/generic-sql": {
+      "development": "./src/adapters/generic-sql/generic-sql-adapter.ts",
+      "types": "./dist/adapters/generic-sql/generic-sql-adapter.d.ts",
+      "default": "./dist/adapters/generic-sql/generic-sql-adapter.js"
+    },
     "./unit-of-work": {
-      "development": "./src/query/unit-of-work.ts",
-      "types": "./dist/query/unit-of-work.d.ts",
-      "default": "./dist/query/unit-of-work.js"
+      "development": "./src/query/unit-of-work/unit-of-work.ts",
+      "types": "./dist/query/unit-of-work/unit-of-work.d.ts",
+      "default": "./dist/query/unit-of-work/unit-of-work.js"
     },
     "./cursor": {
       "development": "./src/query/cursor.ts",
@@ -72,16 +97,18 @@
   "devDependencies": {
     "@electric-sql/pglite": "^0.3.10",
     "@libsql/client": "^0.15.15",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22",
     "@vitest/coverage-istanbul": "^3.2.4",
+    "better-sqlite3": "^12.5.0",
     "drizzle-kit": "^0.31.5",
     "drizzle-orm": "^0.44.6",
     "kysely-pglite": "^0.6.1",
     "mysql2": "^3.11.5",
+    "sqlocal": "^0.15.2",
     "vitest": "^3.2.4",
     "zod": "^4.1.12",
-    "sqlocal": "^0.15.2",
-    "@fragno-dev/core": "0.1.9",
+    "@fragno-dev/core": "0.1.11",
     "@fragno-private/typescript-config": "0.0.1",
     "@fragno-private/vitest-config": "0.0.0"
   },
@@ -93,7 +120,7 @@
   "homepage": "https://fragno.dev",
   "license": "MIT",
   "dependencies": {
-    "@paralleldrive/cuid2": "^2.2.2",
+    "@paralleldrive/cuid2": "^2.3.1",
     "kysely": "^0.28.7"
   },
   "peerDependencies": {

package/src/adapters/adapters.ts

@@ -1,9 +1,9 @@
-import type { Migrator } from "../migration-engine/create";
-import type { AbstractQuery } from "../query/query";
+import type { SimpleQueryInterface } from "../query/simple-query-interface";
 import type { SchemaGenerator } from "../schema-generator/schema-generator";
 import type { AnySchema } from "../schema/create";
 import type { RequestContextStorage } from "@fragno-dev/core/internal/request-context-storage";
-import type { IUnitOfWork } from "../query/unit-of-work";
+import type { IUnitOfWork } from "../query/unit-of-work/unit-of-work";
+import type { PreparedMigrations } from "./generic-sql/migration/prepared-migrations";
 
 export const fragnoDatabaseAdapterNameFakeSymbol = "$fragno-database-adapter-name" as const;
 export const fragnoDatabaseAdapterVersionFakeSymbol = "$fragno-database-adapter-version" as const;
@@ -42,9 +42,12 @@ export interface DatabaseAdapter<TUOWConfig = void> {
   createQueryEngine: <const T extends AnySchema>(
     schema: T,
     namespace: string,
-  ) => AbstractQuery<T, TUOWConfig>;
+  ) => SimpleQueryInterface<T, TUOWConfig>;
 
-  createMigrationEngine?: <const T extends AnySchema>(schema: T, namespace: string) => Migrator;
+  prepareMigrations?: <const T extends AnySchema>(
+    schema: T,
+    namespace: string,
+  ) => PreparedMigrations;
 
   /**
    * Generate a combined schema file from one or more fragments.

package/src/adapters/drizzle/drizzle-adapter-pglite.test.ts

@@ -1,19 +1,17 @@
-import { drizzle } from "drizzle-orm/pglite";
+import { PGlite } from "@electric-sql/pglite";
+import { KyselyPGlite } from "kysely-pglite";
 import { DrizzleAdapter } from "./drizzle-adapter";
 import { beforeAll, describe, expect, expectTypeOf, it } from "vitest";
 import { column, idColumn, referenceColumn, schema } from "../../schema/create";
-import type { DBType } from "./shared";
-import { createRequire } from "node:module";
 import { Cursor } from "../../query/cursor";
-import type { DrizzleCompiledQuery } from "./drizzle-uow-compiler";
-import { writeAndLoadSchema } from "./test-utils";
-
-// Import drizzle-kit for migrations
-const require = createRequire(import.meta.url);
-const { generateDrizzleJson, generateMigration } =
-  require("drizzle-kit/api") as typeof import("drizzle-kit/api");
+import { PGLiteDriverConfig } from "../generic-sql/driver-config";
+import type { CompiledQuery } from "../../sql-driver/sql-driver";
+import { internalSchema } from "../../fragments/internal-fragment";
 
 describe("DrizzleAdapter PGLite", () => {
+  let pgliteDatabase: PGlite;
+  let adapter: DrizzleAdapter;
+
   const testSchema = schema((s) => {
     return s
       .addTable("users", (t) => {
@@ -75,43 +73,54 @@ describe("DrizzleAdapter PGLite", () => {
       });
   });
 
-  let adapter: DrizzleAdapter;
-  let db: DBType;
+  const schema2 = schema((s) => {
+    return s
+      .addTable("products", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("name", column("string"))
+          .addColumn("price", column("integer"))
+          .createIndex("name_idx", ["name"]);
+      })
+      .addTable("orders", (t) => {
+        return t
+          .addColumn("id", idColumn())
+          .addColumn("product_id", referenceColumn())
+          .addColumn("quantity", column("integer"))
+          .addColumn("user_id", referenceColumn())
+          .createIndex("orders_user_idx", ["user_id"])
+          .createIndex("orders_product_idx", ["product_id"]);
+      });
+  });
 
   beforeAll(async () => {
-    // Write schema to file and dynamically import it
-    const { schemaModule, cleanup } = await writeAndLoadSchema(
-      "drizzle-adapter-pglite",
-      testSchema,
-      "postgresql",
-      "namespace",
-    );
+    pgliteDatabase = new PGlite();
 
-    // Create Drizzle instance with PGLite (in-memory Postgres)
-    db = drizzle({
-      schema: schemaModule,
-    }) as unknown as DBType;
+    const { dialect } = new KyselyPGlite(pgliteDatabase);
 
-    // Generate and run migrations
-    const migrationStatements = await generateMigration(
-      generateDrizzleJson({}), // Empty schema (starting state)
-      generateDrizzleJson(schemaModule), // Target schema
-    );
+    adapter = new DrizzleAdapter({
+      dialect,
+      driverConfig: new PGLiteDriverConfig(),
+    });
 
-    // Execute migration SQL
-    for (const statement of migrationStatements) {
-      await db.execute(statement);
+    // Create settings table first (needed for version tracking)
+    {
+      const migrations = adapter.prepareMigrations(internalSchema, "");
+      await migrations.executeWithDriver(adapter.driver, 0);
     }
 
-    adapter = new DrizzleAdapter({
-      db: () => db,
-      provider: "postgresql",
-    });
+    {
+      const migrations = adapter.prepareMigrations(testSchema, "namespace");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
-    expect(await adapter.isConnectionHealthy()).toBe(true);
+    {
+      const migrations = adapter.prepareMigrations(schema2, "namespace2");
+      await migrations.executeWithDriver(adapter.driver, 0);
+    }
 
     return async () => {
-      await cleanup();
+      await adapter.close();
     };
   }, 12000);
 
@@ -277,7 +286,7 @@ describe("DrizzleAdapter PGLite", () => {
 
   it("should support joins", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
-    const queries: DrizzleCompiledQuery[] = [];
+    const queries: CompiledQuery[] = [];
 
     const createUow = queryEngine.createUnitOfWork("create-users");
     createUow.create("users", { name: "Email User", age: 20 });
@@ -312,23 +321,23 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "emails_namespace"."id", "emails_namespace"."user_id", "emails_namespace"."email", "emails_namespace"."is_primary", "emails_namespace"."_internalId", "emails_namespace"."_version", "emails_namespace_user"."data" as "user" from "emails_namespace" "emails_namespace" left join lateral (select json_build_array("emails_namespace_user"."name", "emails_namespace_user"."id", "emails_namespace_user"."age", "emails_namespace_user"."_internalId", "emails_namespace_user"."_version") as "data" from (select * from "users_namespace" "emails_namespace_user" where "emails_namespace_user"."_internalId" = "emails_namespace"."user_id" limit $1) "emails_namespace_user") "emails_namespace_user" on true"`,
+      `"select "user"."name" as "user:name", "user"."id" as "user:id", "user"."age" as "user:age", "user"."_internalId" as "user:_internalId", "user"."_version" as "user:_version", "emails_namespace"."id" as "id", "emails_namespace"."user_id" as "user_id", "emails_namespace"."email" as "email", "emails_namespace"."is_primary" as "is_primary", "emails_namespace"."_internalId" as "_internalId", "emails_namespace"."_version" as "_version" from "emails_namespace" left join "users_namespace" as "user" on "emails_namespace"."user_id" = "user"."_internalId""`,
     );
 
     expect(email).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       user_id: expect.objectContaining({
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       email: "test@example.com",
       is_primary: true,
       user: {
         id: expect.objectContaining({
           externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-          internalId: expect.any(Number),
+          internalId: expect.any(BigInt),
         }),
         name: existingUser.name,
         age: existingUser.age,
@@ -390,7 +399,7 @@ describe("DrizzleAdapter PGLite", () => {
 
   it("should support complex nested joins (comments -> post -> author)", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
-    const queries: DrizzleCompiledQuery[] = [];
+    const queries: CompiledQuery[] = [];
 
     // Create a user (author)
     const createAuthorUow = queryEngine.createUnitOfWork("create-author");
@@ -463,7 +472,7 @@ describe("DrizzleAdapter PGLite", () => {
     expect(comment).toMatchObject({
       id: expect.objectContaining({
         externalId: expect.stringMatching(/^[a-z0-9]{20,}$/),
-        internalId: expect.any(Number),
+        internalId: expect.any(BigInt),
       }),
       text: "Great post!",
       // Post join (first level)
@@ -493,127 +502,8 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [query] = queries;
     expect(query.sql).toMatchInlineSnapshot(
-      `"select "comments_namespace"."id", "comments_namespace"."post_id", "comments_namespace"."user_id", "comments_namespace"."text", "comments_namespace"."_internalId", "comments_namespace"."_version", "comments_namespace_post"."data" as "post", "comments_namespace_commenter"."data" as "commenter" from "comments_namespace" "comments_namespace" left join lateral (select json_build_array("comments_namespace_post"."id", "comments_namespace_post"."title", "comments_namespace_post"."content", "comments_namespace_post"."_internalId", "comments_namespace_post"."_version", "comments_namespace_post_author"."data") as "data" from (select * from "posts_namespace" "comments_namespace_post" where "comments_namespace_post"."_internalId" = "comments_namespace"."post_id" order by "comments_namespace_post"."id" desc limit $1) "comments_namespace_post" left join lateral (select json_build_array("comments_namespace_post_author"."id", "comments_namespace_post_author"."name", "comments_namespace_post_author"."age", "comments_namespace_post_author"."_internalId", "comments_namespace_post_author"."_version") as "data" from (select * from "users_namespace" "comments_namespace_post_author" where "comments_namespace_post_author"."_internalId" = "comments_namespace_post"."user_id" order by "comments_namespace_post_author"."name" asc limit $2) "comments_namespace_post_author") "comments_namespace_post_author" on true) "comments_namespace_post" on true left join lateral (select json_build_array("comments_namespace_commenter"."id", "comments_namespace_commenter"."name", "comments_namespace_commenter"."_internalId", "comments_namespace_commenter"."_version") as "data" from (select * from "users_namespace" "comments_namespace_commenter" where "comments_namespace_commenter"."_internalId" = "comments_namespace"."user_id" limit $3) "comments_namespace_commenter") "comments_namespace_commenter" on true"`,
-    );
-  });
-
-  it("should support joins with convenience aliases when relations are also aliased", async () => {
-    // This test demonstrates the solution: include BOTH table aliases AND relations aliases
-    // in the same schema object. This works around Drizzle's relation resolution bug.
-    //
-    // The bug: When Drizzle processes a relational query with `.join()`, it looks up
-    // tableConfig.relations[relationKey]. If the tableConfig comes from an alias that
-    // doesn't have matching relations, it returns undefined and crashes.
-    //
-    // The fix: For each table alias (e.g., `user`), also add a relations alias
-    // (e.g., `userRelations`) pointing to the same relations object.
-
-    const authSchema = schema((s) => {
-      return s
-        .addTable("user", (t) => {
-          return t
-            .addColumn("id", idColumn())
-            .addColumn("email", column("string"))
-            .addColumn("passwordHash", column("string"));
-        })
-        .addTable("session", (t) => {
-          return t
-            .addColumn("id", idColumn())
-            .addColumn("userId", referenceColumn())
-            .addColumn("expiresAt", column("timestamp"));
-        })
-        .addReference("sessionOwner", {
-          from: { table: "session", column: "userId" },
-          to: { table: "user", column: "id" },
-          type: "one",
-        });
-    });
-
-    // Generate schema with BOTH table aliases AND relations aliases
-    const { schemaModule, cleanup } = await writeAndLoadSchema(
-      "drizzle-adapter-with-relations-aliases",
-      authSchema,
-      "postgresql",
-      "test-namespace",
+      `"select "post"."id" as "post:id", "post"."title" as "post:title", "post"."content" as "post:content", "post"."_internalId" as "post:_internalId", "post"."_version" as "post:_version", "post_author"."id" as "post:author:id", "post_author"."name" as "post:author:name", "post_author"."age" as "post:author:age", "post_author"."_internalId" as "post:author:_internalId", "post_author"."_version" as "post:author:_version", "commenter"."id" as "commenter:id", "commenter"."name" as "commenter:name", "commenter"."_internalId" as "commenter:_internalId", "commenter"."_version" as "commenter:_version", "comments_namespace"."id" as "id", "comments_namespace"."post_id" as "post_id", "comments_namespace"."user_id" as "user_id", "comments_namespace"."text" as "text", "comments_namespace"."_internalId" as "_internalId", "comments_namespace"."_version" as "_version" from "comments_namespace" left join "posts_namespace" as "post" on "comments_namespace"."post_id" = "post"."_internalId" left join "users_namespace" as "post_author" on "post"."user_id" = "post_author"."_internalId" left join "users_namespace" as "commenter" on "comments_namespace"."user_id" = "commenter"."_internalId""`,
     );
-
-    // The schema now includes:
-    // - user_test_namespace + user_test_namespaceRelations (physical)
-    // - user + userRelations (aliases that point to the same objects)
-    const schemaWithAliases = {
-      ...schemaModule.test_namespace_schema,
-    };
-
-    // Create Drizzle instance
-    const db = drizzle({
-      schema: schemaWithAliases,
-    }) as unknown as DBType;
-
-    // Generate and run migrations
-    const require = createRequire(import.meta.url);
-    const { generateDrizzleJson, generateMigration } =
-      require("drizzle-kit/api") as typeof import("drizzle-kit/api");
-
-    const migrationStatements = await generateMigration(
-      generateDrizzleJson({}),
-      generateDrizzleJson(schemaModule),
-    );
-
-    for (const statement of migrationStatements) {
-      await db.execute(statement);
-    }
-
-    const adapter = new DrizzleAdapter({
-      db: async () => db,
-      provider: "postgresql",
-    });
-
-    await adapter.isConnectionHealthy();
-    const queryEngine = adapter.createQueryEngine(authSchema, "test-namespace");
-
-    // Create a user
-    const createUserUow = queryEngine.createUnitOfWork("create-user");
-    createUserUow.create("user", {
-      email: "test@example.com",
-      passwordHash: "hash",
-    });
-    await createUserUow.executeMutations();
-
-    // Create a session
-    const [[user]] = await queryEngine.createUnitOfWork("get-user").find("user").executeRetrieve();
-
-    const createSessionUow = queryEngine.createUnitOfWork("create-session");
-    createSessionUow.create("session", {
-      userId: user.id,
-      expiresAt: new Date("2025-12-31"),
-    });
-    await createSessionUow.executeMutations();
-
-    // Get session
-    const [[session]] = await queryEngine
-      .createUnitOfWork("get-session")
-      .find("session")
-      .executeRetrieve();
-
-    // Find session with join - this works now!
-    // The key is that when Drizzle looks up the session's relations,
-    // it finds BOTH `sessionOwner` (from session_test_namespaceRelations)
-    // AND the same relations via `sessionRelations` (the alias)
-    const [[sessionWithUser]] = await queryEngine
-      .createUnitOfWork("find-session-with-join")
-      .find("session", (b) =>
-        b
-          .whereIndex("primary", (eb) => eb("id", "=", session.id.valueOf()))
-          .join((j) => j.sessionOwner((b) => b.select(["id", "email"]))),
-      )
-      .executeRetrieve();
-
-    // Verify the join worked
-    expect(sessionWithUser).toBeDefined();
-    expect(sessionWithUser.sessionOwner).toBeDefined();
-    expect(sessionWithUser.sessionOwner?.email).toBe("test@example.com");
-
-    await cleanup();
   });
 
   it("should handle timestamps and timezones correctly", async () => {
@@ -673,7 +563,7 @@ describe("DrizzleAdapter PGLite", () => {
 
   it("should create user and post in same transaction using returned ID", async () => {
     const queryEngine = adapter.createQueryEngine(testSchema, "namespace");
-    const queries: DrizzleCompiledQuery[] = [];
+    const queries: CompiledQuery[] = [];
 
     // Create UOW and create both user and post in same transaction
     const uow = queryEngine.createUnitOfWork("create-user-and-post", {
@@ -723,15 +613,16 @@ describe("DrizzleAdapter PGLite", () => {
 
     const [insertUserQuery, insertPostQuery] = queries;
     expect(insertUserQuery.sql).toMatchInlineSnapshot(
-      `"insert into "users_namespace" ("id", "name", "age", "_internalId", "_version") values ($1, $2, $3, default, default)"`,
+      `"insert into "users_namespace" ("id", "name", "age") values ($1, $2, $3) returning "users_namespace"."id" as "id", "users_namespace"."name" as "name", "users_namespace"."age" as "age", "users_namespace"."_internalId" as "_internalId", "users_namespace"."_version" as "_version""`,
     );
-    expect(insertUserQuery.params).toEqual([userId.externalId, "UOW Test User", 35]);
+    expect(insertUserQuery.parameters).toEqual([userId.externalId, "UOW Test User", 35]);
     expect(insertPostQuery.sql).toMatchInlineSnapshot(
-      `"insert into "posts_namespace" ("id", "user_id", "title", "content", "created_at", "_internalId", "_version") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit 1), $3, $4, default, default, default)"`,
+      `"insert into "posts_namespace" ("id", "user_id", "title", "content") values ($1, (select "_internalId" from "users_namespace" where "id" = $2 limit $3), $4, $5) returning "posts_namespace"."id" as "id", "posts_namespace"."user_id" as "user_id", "posts_namespace"."title" as "title", "posts_namespace"."content" as "content", "posts_namespace"."created_at" as "created_at", "posts_namespace"."_internalId" as "_internalId", "posts_namespace"."_version" as "_version""`,
     );
-    expect(insertPostQuery.params).toEqual([
+    expect(insertPostQuery.parameters).toEqual([
       postId.externalId,
       userId.externalId,
+      1,
       "UOW Test Post",
       "This post was created in the same transaction as the user",
     ]);