drizzle-orm-libsql-sync 0.0.0

package/README.md

@@ -0,0 +1,83 @@
+# drizzle-orm-libsql-sync
+
+A **synchronous** [Drizzle ORM](https://orm.drizzle.team) driver for
+[`libsql`](https://github.com/tursodatabase/libsql-js), backed directly by the
+libsql `Database` (`prepare`/`exec`) and targeting Drizzle v1's modern relations.
+
+## Why this exists
+
+Drizzle ships two relevant SQLite drivers, but neither fits a sync + libsql +
+modern-relations use case:
+
+- **`drizzle-orm/libsql`** is **async** (`await db.execute(...)`). Great for
+  Turso over the network, but heavy for serial Node/Bun build scripts, test
+  seeding, and benchmarks where every row insert would otherwise be `await`ed.
+- **`drizzle-orm/better-sqlite3`** is sync, but it does a top-level
+  `import Client from "better-sqlite3"` (forcing that dependency) and historically
+  targeted Drizzle's legacy relational system.
+
+This package gives you the missing combination: a real
+`BaseSQLiteDatabase<"sync", …>` whose `select()/insert()/...` return rows
+directly, bound to a libsql `Database`. libsql is a SQLite superset (more `ALTER`
+statements, encryption-at-rest, extensions), so it's a strong local engine for
+build/CLI/test code.
+
+> **Note:** This is for **synchronous, local** work (Node/Bun build scripts,
+> fixtures, benchmarks). For your app talking to Turso over the network, keep
+> using the official async `drizzle-orm/libsql`.
+
+## Install
+
+```bash
+npm i drizzle-orm-libsql-sync drizzle-orm libsql
+```
+
+`drizzle-orm` and `libsql` are peer dependencies.
+
+## Usage
+
+```ts
+import Database from "libsql";
+import { drizzle } from "drizzle-orm-libsql-sync";
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const users = sqliteTable("users", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  name: text("name").notNull(),
+});
+
+// Pass a path…
+const db = drizzle("file:local.db", { schema: { users } });
+
+// …or an existing libsql client…
+const client = new Database(":memory:");
+const db2 = drizzle(client, { schema: { users } });
+
+// …or the config-object form:
+const db3 = drizzle({ client, schema: { users } });
+
+// Synchronous — no await:
+db.insert(users).values({ name: "ada" }).run();
+const rows = db.select().from(users).all();
+```
+
+### Migrations
+
+```ts
+import { migrate } from "drizzle-orm-libsql-sync/migrator";
+
+migrate(db, { migrationsFolder: "./drizzle" });
+```
+
+### Transactions
+
+```ts
+db.transaction((tx) => {
+  tx.insert(users).values({ name: "grace" }).run();
+  // throw to roll back; nested transactions use SAVEPOINTs
+});
+```
+
+## License
+
+MIT

package/dist/client-xqwnbWL8.d.mts

@@ -0,0 +1,10 @@
+import { Database } from "libsql";
+
+//#region src/client.d.ts
+type DrizzleSyncSQLiteBindValue = null | string | number | bigint | boolean | Uint8Array;
+/** The libsql `Database` surface the sync session relies on. */
+type DrizzleSyncSQLiteClient = Database;
+declare function isDrizzleSyncSQLiteClient(value: unknown): value is DrizzleSyncSQLiteClient;
+declare function toDrizzleSyncSQLiteClient(value: unknown): DrizzleSyncSQLiteClient;
+//#endregion
+export { toDrizzleSyncSQLiteClient as i, DrizzleSyncSQLiteClient as n, isDrizzleSyncSQLiteClient as r, DrizzleSyncSQLiteBindValue as t };

package/dist/client.d.mts

@@ -0,0 +1,2 @@
+import { i as toDrizzleSyncSQLiteClient, n as DrizzleSyncSQLiteClient, r as isDrizzleSyncSQLiteClient, t as DrizzleSyncSQLiteBindValue } from "./client-xqwnbWL8.mjs";
+export { DrizzleSyncSQLiteBindValue, DrizzleSyncSQLiteClient, isDrizzleSyncSQLiteClient, toDrizzleSyncSQLiteClient };

package/dist/client.mjs

@@ -0,0 +1,11 @@
+//#region src/client.ts
+function isDrizzleSyncSQLiteClient(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return typeof Reflect.get(value, "prepare") === "function" && typeof Reflect.get(value, "exec") === "function";
+}
+function toDrizzleSyncSQLiteClient(value) {
+	if (!isDrizzleSyncSQLiteClient(value)) throw new TypeError("Expected a libsql-compatible synchronous SQLite client.");
+	return value;
+}
+//#endregion
+export { isDrizzleSyncSQLiteClient, toDrizzleSyncSQLiteClient };

package/dist/driver.d.mts

@@ -0,0 +1,28 @@
+import { n as LibsqlSyncRunResult } from "./session-DuHpmegi.mjs";
+import { Database } from "libsql";
+import { AnyRelations, DrizzleConfig, EmptyRelations, entityKind } from "drizzle-orm";
+import { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";
+
+//#region src/driver.d.ts
+/** Config-object form accepted by the call sites. */
+type LibsqlSyncDrizzleConfig<TSchema extends Record<string, unknown>, TRelations extends AnyRelations> = DrizzleConfig<TSchema, TRelations> & {
+  client: Database;
+};
+declare class LibsqlSyncDatabase<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations> extends BaseSQLiteDatabase<"sync", LibsqlSyncRunResult, TSchema, TRelations> {
+  static readonly [entityKind]: string;
+  $client: Database;
+}
+declare function drizzleImpl<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations>(...params: [string] | [string, DrizzleConfig<TSchema, TRelations>] | [Database] | [Database, DrizzleConfig<TSchema, TRelations>] | [LibsqlSyncDrizzleConfig<TSchema, TRelations>]): LibsqlSyncDatabase<TSchema, TRelations> & {
+  $client: Database;
+};
+/**
+ * Mirrors `drizzle-orm/better-sqlite3`'s `drizzle.mock` — an in-memory libsql
+ * database, handy for type-only fixtures and tests that never touch a real
+ * connection.
+ */
+declare function mock<TSchema extends Record<string, unknown> = Record<string, never>, TRelations extends AnyRelations = EmptyRelations>(config?: DrizzleConfig<TSchema, TRelations>): LibsqlSyncDatabase<TSchema, TRelations>;
+declare const drizzle: typeof drizzleImpl & {
+  mock: typeof mock;
+};
+//#endregion
+export { LibsqlSyncDatabase, LibsqlSyncDrizzleConfig, drizzle };

package/dist/driver.mjs

@@ -0,0 +1,64 @@
+import { toDrizzleSyncSQLiteClient } from "./client.mjs";
+import { LibsqlSyncSession } from "./session.mjs";
+import LibsqlDatabaseCtor from "libsql";
+import { DefaultLogger, entityKind } from "drizzle-orm";
+import * as V1 from "drizzle-orm/_relations";
+import { BaseSQLiteDatabase, SQLiteSyncDialect } from "drizzle-orm/sqlite-core";
+//#region src/driver.ts
+function isAnyObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isRelationsConfig(value) {
+	return isAnyObject(value);
+}
+function isExtractedSchemaTables(value) {
+	return isAnyObject(value);
+}
+var LibsqlSyncDatabase = class extends BaseSQLiteDatabase {
+	static [entityKind] = "LibsqlSyncDatabase";
+};
+function construct(client, drizzleConfig = {}) {
+	const sqliteClient = toDrizzleSyncSQLiteClient(client);
+	const dialect = new SQLiteSyncDialect();
+	let logger;
+	if (drizzleConfig.logger === true) logger = new DefaultLogger();
+	else if (drizzleConfig.logger !== false) logger = drizzleConfig.logger;
+	let schema;
+	if (drizzleConfig.schema) {
+		const tablesConfig = V1.extractTablesRelationalConfig(drizzleConfig.schema, V1.createTableRelationsHelpers);
+		if (!isExtractedSchemaTables(tablesConfig.tables)) throw new TypeError("Invalid relational schema tables config");
+		schema = {
+			fullSchema: drizzleConfig.schema,
+			schema: tablesConfig.tables,
+			tableNamesMap: tablesConfig.tableNamesMap
+		};
+	}
+	const relations = drizzleConfig.relations ?? {};
+	if (!isRelationsConfig(relations)) throw new TypeError("Invalid drizzle relations config");
+	const db = new LibsqlSyncDatabase("sync", dialect, new LibsqlSyncSession(sqliteClient, dialect, relations, schema, { logger }), relations, schema);
+	db.$client = sqliteClient;
+	return db;
+}
+function isLibsqlSyncDrizzleConfig(value) {
+	return isAnyObject(value) && "client" in value && isAnyObject(Reflect.get(value, "client"));
+}
+function drizzleImpl(...params) {
+	const [first, second] = params;
+	if (typeof first === "string") return construct(new LibsqlDatabaseCtor(first), second);
+	if (isLibsqlSyncDrizzleConfig(first)) {
+		const { client, ...drizzleConfig } = first;
+		return construct(client, drizzleConfig);
+	}
+	return construct(first, second);
+}
+/**
+* Mirrors `drizzle-orm/better-sqlite3`'s `drizzle.mock` — an in-memory libsql
+* database, handy for type-only fixtures and tests that never touch a real
+* connection.
+*/
+function mock(config) {
+	return construct(new LibsqlDatabaseCtor(":memory:"), config);
+}
+const drizzle = Object.assign(drizzleImpl, { mock });
+//#endregion
+export { LibsqlSyncDatabase, drizzle };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { i as toDrizzleSyncSQLiteClient, n as DrizzleSyncSQLiteClient, r as isDrizzleSyncSQLiteClient, t as DrizzleSyncSQLiteBindValue } from "./client-xqwnbWL8.mjs";
+import { a as LibsqlSyncTransaction, i as LibsqlSyncSessionOptions, n as LibsqlSyncRunResult, r as LibsqlSyncSession, t as LibsqlSyncPreparedQuery } from "./session-DuHpmegi.mjs";
+import { LibsqlSyncDatabase, LibsqlSyncDrizzleConfig, drizzle } from "./driver.mjs";
+export { type DrizzleSyncSQLiteBindValue, type DrizzleSyncSQLiteClient, LibsqlSyncDatabase, LibsqlSyncDrizzleConfig, LibsqlSyncPreparedQuery, LibsqlSyncRunResult, LibsqlSyncSession, LibsqlSyncSessionOptions, LibsqlSyncTransaction, drizzle, isDrizzleSyncSQLiteClient, toDrizzleSyncSQLiteClient };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { isDrizzleSyncSQLiteClient, toDrizzleSyncSQLiteClient } from "./client.mjs";
+import { LibsqlSyncPreparedQuery, LibsqlSyncSession, LibsqlSyncTransaction } from "./session.mjs";
+import { LibsqlSyncDatabase, drizzle } from "./driver.mjs";
+export { LibsqlSyncDatabase, LibsqlSyncPreparedQuery, LibsqlSyncSession, LibsqlSyncTransaction, drizzle, isDrizzleSyncSQLiteClient, toDrizzleSyncSQLiteClient };

package/dist/migrator.d.mts

@@ -0,0 +1,8 @@
+import { LibsqlSyncDatabase } from "./driver.mjs";
+import { AnyRelations } from "drizzle-orm";
+import { MigrationConfig } from "drizzle-orm/migrator";
+
+//#region src/migrator.d.ts
+declare function migrate<TSchema extends Record<string, unknown>, TRelations extends AnyRelations>(db: LibsqlSyncDatabase<TSchema, TRelations>, config: MigrationConfig): void;
+//#endregion
+export { migrate };

package/dist/migrator.mjs

@@ -0,0 +1,17 @@
+import { readMigrationFiles } from "drizzle-orm/migrator";
+//#region src/migrator.ts
+function migrate(db, config) {
+	const migrations = readMigrationFiles(config);
+	const dialect = Reflect.get(db, "dialect");
+	const session = Reflect.get(db, "session");
+	if (typeof dialect !== "object" || dialect === null || !("migrate" in dialect)) throw new TypeError("Database dialect does not expose migrate()");
+	const migrateFn = Reflect.get(dialect, "migrate");
+	if (typeof migrateFn !== "function") throw new TypeError("Database dialect migrate is not a function");
+	Reflect.apply(migrateFn, dialect, [
+		migrations,
+		session,
+		config
+	]);
+}
+//#endregion
+export { migrate };

package/dist/session-DuHpmegi.d.mts

@@ -0,0 +1,66 @@
+import { n as DrizzleSyncSQLiteClient } from "./client-xqwnbWL8.mjs";
+import { AnyRelations, DrizzleTypeError, Logger, Query, RelationalQueryMapperConfig, entityKind } from "drizzle-orm";
+import * as V1 from "drizzle-orm/_relations";
+import { PreparedQueryConfig, SQLiteExecuteMethod, SQLitePreparedQuery, SQLiteSession, SQLiteSyncDialect, SQLiteTransaction, SQLiteTransactionConfig, SelectedFieldsOrdered } from "drizzle-orm/sqlite-core";
+import { WithCacheConfig } from "drizzle-orm/cache/core/types";
+
+//#region src/session.d.ts
+interface LibsqlSyncSessionOptions {
+  logger?: Logger;
+  useJitMappers?: boolean;
+}
+interface LibsqlSyncRunResult {
+  changes: number;
+  lastInsertRowid: number | bigint;
+}
+type PreparedQueryConfig$1 = Omit<PreparedQueryConfig, "statement" | "run">;
+declare class LibsqlSyncSession<TFullSchema extends Record<string, unknown>, TRelations extends AnyRelations, TSchema extends V1.TablesRelationalConfig> extends SQLiteSession<"sync", LibsqlSyncRunResult, TFullSchema, TRelations, TSchema> {
+  private client;
+  private relations;
+  private schema;
+  private options;
+  static readonly [entityKind]: string;
+  private logger;
+  constructor(client: DrizzleSyncSQLiteClient, dialect: SQLiteSyncDialect, relations: TRelations, schema: V1.RelationalSchemaConfig<TSchema> | undefined, options?: LibsqlSyncSessionOptions);
+  prepareQuery<T extends Omit<PreparedQueryConfig$1, "run">>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper?: (rows: unknown[][], mapColumnValue?: (value: unknown) => unknown) => unknown, queryMetadata?: {
+    tables: string[];
+    type: "select" | "update" | "delete" | "insert";
+  }, _cacheConfig?: WithCacheConfig): LibsqlSyncPreparedQuery<T>;
+  prepareRelationalQuery<T extends Omit<PreparedQueryConfig$1, "run">>(query: Query, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, customResultMapper: (rows: Record<string, unknown>[], mapColumnValue?: (value: unknown) => unknown) => unknown, config: RelationalQueryMapperConfig): LibsqlSyncPreparedQuery<T, true>;
+  transaction<T>(transaction: (tx: LibsqlSyncTransaction<TFullSchema, TRelations, TSchema>) => T, config?: SQLiteTransactionConfig): T;
+}
+declare class LibsqlSyncTransaction<TFullSchema extends Record<string, unknown>, TRelations extends AnyRelations, TSchema extends V1.TablesRelationalConfig> extends SQLiteTransaction<"sync", LibsqlSyncRunResult, TFullSchema, TRelations, TSchema> {
+  static readonly [entityKind]: string;
+  transaction<T>(transaction: (tx: LibsqlSyncTransaction<TFullSchema, TRelations, TSchema>) => T extends Promise<any> ? DrizzleTypeError<"Sync drivers can't use async functions in transactions!"> : T): T;
+}
+declare class LibsqlSyncPreparedQuery<T extends PreparedQueryConfig$1 = PreparedQueryConfig$1, TIsRqbV2 extends boolean = false> extends SQLitePreparedQuery<{
+  all: T["all"];
+  execute: T["execute"];
+  get: T["get"];
+  run: LibsqlSyncRunResult;
+  type: "sync";
+  values: T["values"];
+}> {
+  private client;
+  private logger;
+  private fields;
+  private useJitMappers;
+  private customResultMapper?;
+  private isRqbV2Query?;
+  private rqbConfig?;
+  static readonly [entityKind]: string;
+  private jitRowMapper?;
+  private jitRqbMapper?;
+  constructor(client: DrizzleSyncSQLiteClient, query: Query, logger: Logger, queryMetadata: {
+    tables: string[];
+    type: "select" | "update" | "delete" | "insert";
+  } | undefined, fields: SelectedFieldsOrdered | undefined, executeMethod: SQLiteExecuteMethod, useJitMappers: boolean | undefined, customResultMapper?: ((rows: TIsRqbV2 extends true ? Record<string, unknown>[] : unknown[][]) => unknown) | undefined, isRqbV2Query?: TIsRqbV2 | undefined, rqbConfig?: RelationalQueryMapperConfig | undefined);
+  run(placeholderValues?: Record<string, unknown>): LibsqlSyncRunResult;
+  all(placeholderValues?: Record<string, unknown>): T["all"];
+  private allRqbV2;
+  get(placeholderValues?: Record<string, unknown>): T["get"];
+  private getRqbV2;
+  values(placeholderValues?: Record<string, unknown>): T["values"];
+}
+//#endregion
+export { LibsqlSyncTransaction as a, LibsqlSyncSessionOptions as i, LibsqlSyncRunResult as n, LibsqlSyncSession as r, LibsqlSyncPreparedQuery as t };

package/dist/session.d.mts

@@ -0,0 +1,2 @@
+import { a as LibsqlSyncTransaction, i as LibsqlSyncSessionOptions, n as LibsqlSyncRunResult, r as LibsqlSyncSession, t as LibsqlSyncPreparedQuery } from "./session-DuHpmegi.mjs";
+export { LibsqlSyncPreparedQuery, LibsqlSyncRunResult, LibsqlSyncSession, LibsqlSyncSessionOptions, LibsqlSyncTransaction };

package/dist/session.mjs

@@ -0,0 +1,291 @@
+import "./client.mjs";
+import * as drizzleRuntime from "drizzle-orm";
+import { NoopLogger, entityKind, fillPlaceholders, is, makeJitQueryMapper, makeJitRqbMapper, sql } from "drizzle-orm";
+import { SQLitePreparedQuery, SQLiteSession, SQLiteTransaction } from "drizzle-orm/sqlite-core";
+//#region src/session.ts
+function isAnyObject(value) {
+	return typeof value === "object" && value !== null;
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Sync one-shot memoizer for the `drizzle-orm` runtime export lookups below.
+* Avoids a `let cached…` module singleton while keeping the lookup off the hot
+* path.
+*/
+function onetime(fn) {
+	let called = false;
+	let value;
+	return () => {
+		if (!called) {
+			value = fn();
+			called = true;
+		}
+		return value;
+	};
+}
+function getDrizzleRuntimeFunction(exportName, validate) {
+	const value = Reflect.get(drizzleRuntime, exportName);
+	if (!validate(value)) throw new TypeError(`drizzle-orm is missing runtime export: ${exportName}`);
+	return value;
+}
+const getMapResultRow = onetime(() => getDrizzleRuntimeFunction("mapResultRow", (value) => typeof value === "function"));
+function isSqliteBindValue(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean" || value instanceof Uint8Array;
+}
+function toSqliteBindValues(params) {
+	const bindValues = [];
+	for (const param of params) {
+		if (!isSqliteBindValue(param)) throw new TypeError(`Invalid SQLite bind value: ${JSON.stringify(param)}`);
+		bindValues.push(param);
+	}
+	return bindValues;
+}
+function isRecordBooleanMap(value) {
+	if (value === void 0) return true;
+	if (!isPlainObject(value)) return false;
+	return Object.values(value).every((entry) => typeof entry === "boolean");
+}
+function isSQLiteSyncDialect(value) {
+	return isAnyObject(value) && "sqlToQuery" in value;
+}
+function getPreparedQueryInternals(instance) {
+	const joinsNotNullableMap = Reflect.get(instance, "joinsNotNullableMap");
+	if (!isRecordBooleanMap(joinsNotNullableMap)) throw new TypeError("Prepared query is missing joinsNotNullableMap");
+	return { joinsNotNullableMap };
+}
+function getSQLiteSyncDialect(instance) {
+	const dialect = Reflect.get(instance, "dialect");
+	if (!isSQLiteSyncDialect(dialect)) throw new TypeError("Missing SQLite sync dialect");
+	return dialect;
+}
+function isPreparedQueryResult(value) {
+	return true;
+}
+function isRqbV2CustomResultMapper(mapper, isRqbV2) {
+	return isRqbV2 === true && typeof mapper === "function";
+}
+function isLibsqlSyncSessionFor(value) {
+	return is(value, LibsqlSyncSession);
+}
+function getSelectedFields(fields) {
+	if (fields === void 0) throw new TypeError("Expected selected fields to be defined");
+	return fields;
+}
+function getRelationalQueryMapperConfig(config) {
+	if (config === void 0) throw new TypeError("Expected relational query mapper config to be defined");
+	return config;
+}
+var LibsqlSyncSession = class extends SQLiteSession {
+	client;
+	relations;
+	schema;
+	options;
+	static [entityKind] = "LibsqlSyncSession";
+	logger;
+	constructor(client, dialect, relations, schema, options = {}) {
+		super(dialect);
+		this.client = client;
+		this.relations = relations;
+		this.schema = schema;
+		this.options = options;
+		this.logger = options.logger ?? new NoopLogger();
+	}
+	prepareQuery(query, fields, executeMethod, customResultMapper, queryMetadata, _cacheConfig) {
+		return new LibsqlSyncPreparedQuery(this.client, query, this.logger, queryMetadata, fields, executeMethod, this.options.useJitMappers, customResultMapper);
+	}
+	prepareRelationalQuery(query, fields, executeMethod, customResultMapper, config) {
+		return new LibsqlSyncPreparedQuery(this.client, query, this.logger, void 0, fields, executeMethod, this.options.useJitMappers, customResultMapper, true, config);
+	}
+	transaction(transaction, config = {}) {
+		const tx = new LibsqlSyncTransaction("sync", getSQLiteSyncDialect(this), this, this.relations, this.schema);
+		this.run(sql.raw(`begin${config.behavior ? " " + config.behavior : ""}`));
+		try {
+			const result = transaction(tx);
+			this.run(sql`commit`);
+			return result;
+		} catch (error) {
+			this.run(sql`rollback`);
+			throw error;
+		}
+	}
+};
+var LibsqlSyncTransaction = class LibsqlSyncTransaction extends SQLiteTransaction {
+	static [entityKind] = "LibsqlSyncTransaction";
+	transaction(transaction) {
+		const dialect = getSQLiteSyncDialect(this);
+		const sessionValue = Reflect.get(this, "session");
+		if (!isLibsqlSyncSessionFor(sessionValue)) throw new TypeError("Expected LibsqlSyncSession");
+		const savepointName = `sp${this.nestedIndex}`;
+		const tx = new LibsqlSyncTransaction("sync", dialect, sessionValue, this.relations, this.schema, this.nestedIndex + 1);
+		sessionValue.run(sql.raw(`savepoint ${savepointName}`));
+		try {
+			const result = transaction(tx);
+			sessionValue.run(sql.raw(`release savepoint ${savepointName}`));
+			return result;
+		} catch (error) {
+			sessionValue.run(sql.raw(`rollback to savepoint ${savepointName}`));
+			throw error;
+		}
+	}
+};
+var LibsqlSyncPreparedQuery = class extends SQLitePreparedQuery {
+	client;
+	logger;
+	fields;
+	useJitMappers;
+	customResultMapper;
+	isRqbV2Query;
+	rqbConfig;
+	static [entityKind] = "LibsqlSyncPreparedQuery";
+	jitRowMapper;
+	jitRqbMapper;
+	constructor(client, query, logger, queryMetadata, fields, executeMethod, useJitMappers, customResultMapper, isRqbV2Query, rqbConfig) {
+		super("sync", executeMethod, query, void 0, queryMetadata, void 0);
+		this.client = client;
+		this.logger = logger;
+		this.fields = fields;
+		this.useJitMappers = useJitMappers;
+		this.customResultMapper = customResultMapper;
+		this.isRqbV2Query = isRqbV2Query;
+		this.rqbConfig = rqbConfig;
+	}
+	run(placeholderValues) {
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		const info = this.client.prepare(this.query.sql).run(...toSqliteBindValues(params));
+		return {
+			changes: info.changes,
+			lastInsertRowid: info.lastInsertRowid
+		};
+	}
+	all(placeholderValues) {
+		if (this.isRqbV2Query) return this.allRqbV2(placeholderValues);
+		const internals = getPreparedQueryInternals(this);
+		const { client, customResultMapper, fields, logger, query } = this;
+		const { joinsNotNullableMap } = internals;
+		if (!fields && !customResultMapper) {
+			const params = fillPlaceholders(query.params, placeholderValues ?? {});
+			logger.logQuery(query.sql, params);
+			const result = client.prepare(query.sql).all(...toSqliteBindValues(params));
+			if (isPreparedQueryResult(result)) return result;
+			throw new TypeError("Unexpected prepared query result");
+		}
+		const rows = this.values(placeholderValues);
+		if (!Array.isArray(rows)) throw new TypeError("Expected values() to return row arrays");
+		if (customResultMapper) {
+			const mapped = customResultMapper(rows);
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected custom result mapper output");
+		}
+		const fieldsDefined = getSelectedFields(fields);
+		if (this.useJitMappers) {
+			const mapper = this.jitRowMapper ?? makeJitQueryMapper(fieldsDefined, joinsNotNullableMap);
+			this.jitRowMapper = mapper;
+			const mapped = mapper(rows);
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected JIT mapper output");
+		}
+		const mapped = rows.map((row) => {
+			if (!Array.isArray(row)) throw new TypeError("Expected each row to be an array");
+			return getMapResultRow()(fieldsDefined, row, joinsNotNullableMap);
+		});
+		if (isPreparedQueryResult(mapped)) return mapped;
+		throw new TypeError("Unexpected mapped query result");
+	}
+	allRqbV2(placeholderValues) {
+		const { client, customResultMapper, logger, query } = this;
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
+		const rows = client.prepare(query.sql).all(...toSqliteBindValues(params));
+		const rqbConfig = getRelationalQueryMapperConfig(this.rqbConfig);
+		if (this.useJitMappers) {
+			const mapper = this.jitRqbMapper ?? makeJitRqbMapper(rqbConfig);
+			this.jitRqbMapper = mapper;
+			const mapped = mapper(rows);
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected RQB JIT mapper output");
+		}
+		if (!isRqbV2CustomResultMapper(customResultMapper, this.isRqbV2Query)) throw new TypeError("Expected custom result mapper for RQB v2 query");
+		const mapped = customResultMapper(rows);
+		if (isPreparedQueryResult(mapped)) return mapped;
+		throw new TypeError("Unexpected RQB custom result mapper output");
+	}
+	get(placeholderValues) {
+		if (this.isRqbV2Query) return this.getRqbV2(placeholderValues);
+		const internals = getPreparedQueryInternals(this);
+		const { client, customResultMapper, fields, logger, query } = this;
+		const { joinsNotNullableMap } = internals;
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
+		if (!fields && !customResultMapper) {
+			const row = client.prepare(query.sql).get(...toSqliteBindValues(params)) ?? void 0;
+			if (row === void 0 || row === null) return;
+			if (isPreparedQueryResult(row)) return row;
+			throw new TypeError("Unexpected prepared query row");
+		}
+		const rows = this.values(placeholderValues);
+		if (!Array.isArray(rows)) throw new TypeError("Expected values() to return row arrays");
+		const row = rows[0];
+		if (!row) return;
+		if (customResultMapper) {
+			const mapped = customResultMapper(rows);
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected custom result mapper output");
+		}
+		const fieldsDefined = getSelectedFields(fields);
+		if (this.useJitMappers) {
+			const mapper = this.jitRowMapper ?? makeJitQueryMapper(fieldsDefined, joinsNotNullableMap);
+			this.jitRowMapper = mapper;
+			const mappedRows = mapper([row]);
+			if (!Array.isArray(mappedRows)) throw new TypeError("Expected JIT mapper to return an array");
+			const mapped = mappedRows[0];
+			if (mapped === void 0) return;
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected JIT mapper row");
+		}
+		if (!Array.isArray(row)) throw new TypeError("Expected row to be an array");
+		const mapped = getMapResultRow()(fieldsDefined, row, joinsNotNullableMap);
+		if (isPreparedQueryResult(mapped)) return mapped;
+		throw new TypeError("Unexpected mapped query row");
+	}
+	getRqbV2(placeholderValues) {
+		const { client, customResultMapper, logger, query } = this;
+		const params = fillPlaceholders(query.params, placeholderValues ?? {});
+		logger.logQuery(query.sql, params);
+		const rows = client.prepare(query.sql).all(...toSqliteBindValues(params));
+		const row = rows[0];
+		if (!row) return;
+		const rqbConfig = getRelationalQueryMapperConfig(this.rqbConfig);
+		if (this.useJitMappers) {
+			const mapper = this.jitRqbMapper ?? makeJitRqbMapper(rqbConfig);
+			this.jitRqbMapper = mapper;
+			const mapped = mapper(rows);
+			if (isPreparedQueryResult(mapped)) return mapped;
+			throw new TypeError("Unexpected RQB JIT mapper output");
+		}
+		if (!isRqbV2CustomResultMapper(customResultMapper, this.isRqbV2Query)) throw new TypeError("Expected custom result mapper for RQB v2 query");
+		const mapped = customResultMapper([row]);
+		if (isPreparedQueryResult(mapped)) return mapped;
+		throw new TypeError("Unexpected RQB custom result mapper output");
+	}
+	values(placeholderValues) {
+		const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
+		this.logger.logQuery(this.query.sql, params);
+		const stmt = this.client.prepare(this.query.sql);
+		const toggled = stmt.raw(true);
+		let result;
+		try {
+			result = toggled.all(...toSqliteBindValues(params));
+		} finally {
+			stmt.raw(false);
+		}
+		if (isPreparedQueryResult(result)) return result;
+		throw new TypeError("Unexpected prepared query values");
+	}
+};
+//#endregion
+export { LibsqlSyncPreparedQuery, LibsqlSyncSession, LibsqlSyncTransaction };

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "drizzle-orm-libsql-sync",
+  "version": "0.0.0",
+  "description": "A synchronous Drizzle ORM driver for libsql, backed by the libsql Database (prepare/exec) and drizzle v1 modern relations.",
+  "keywords": [
+    "drizzle",
+    "drizzle-orm",
+    "libsql",
+    "sqlite",
+    "sync",
+    "synchronous",
+    "turso"
+  ],
+  "homepage": "https://github.com/leonsilicon/drizzle-orm-libsql-sync#readme",
+  "bugs": {
+    "url": "https://github.com/leonsilicon/drizzle-orm-libsql-sync/issues"
+  },
+  "license": "MIT",
+  "author": "Leon Si <leon@leonsilicon.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leonsilicon/drizzle-orm-libsql-sync.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./client": "./dist/client.mjs",
+    "./driver": "./dist/driver.mjs",
+    "./migrator": "./dist/migrator.mjs",
+    "./session": "./dist/session.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "prepublishOnly": "vp run build",
+    "prepare": "vp config"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "bumpp": "^11.1.0",
+    "drizzle-orm": "1.0.0-rc.4-5d5b77c",
+    "libsql": "^0.5.29",
+    "typescript": "^6.0.3",
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vite-plus": "latest"
+  },
+  "peerDependencies": {
+    "drizzle-orm": "^1.0.0-rc.4",
+    "libsql": "^0.5.0"
+  },
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vitest": "4.1.9"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "bun",
+      "version": "1.3.14",
+      "onFail": "download"
+    }
+  }
+}