codexuse-cli 2.5.8 → 3.0.2

package/dist/server/NodeSqliteClient-BMOt9qz2.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env bun
+
+import { Ci as void_, Fn as getCurrent, Gi as addFinalizer, Ii as effectServices, Or as gen, Rr as map, Rt as die$1, Ts as identity, Wi as Scope, Zn as acquireUseRelease, _ as unwrap, _r as fail, a as makeCompilerSqlite, ao as add, bi as uninterruptibleMask, br as flatMap, ci as succeed, co as getUnsafe, di as sync, fi as tap, hn as make$1, ho as minutes, i as defaultTransforms, io as Service, lo as make$3, n as SqlClient, nr as as, o as layer$1, pr as die, r as make$2, so as get, t as SafeIntegers, ti as scope, vi as try_, wi as withFiber, zi as provide } from "./SqlClient-CB8oPtuH.mjs";
+import { n as make$4, t as get$1 } from "./index.mjs";
+import { t as SqlError } from "./SqlError-3qccgSvc.mjs";
+import { DatabaseSync } from "node:sqlite";
+//#region src/persistence/NodeSqliteClient.ts
+/**
+* Port of `@effect/sql-sqlite-node` that uses the native `node:sqlite`
+* bindings instead of `better-sqlite3`.
+*
+* @module SqliteClient
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const TypeId = "~local/sqlite-node/SqliteClient";
+/**
+* SqliteClient - Effect service tag for the sqlite SQL client.
+*/
+const SqliteClient = Service("t3/persistence/NodeSqliteClient");
+/**
+* Verify that the current Node.js version includes the `node:sqlite` APIs
+* used by `NodeSqliteClient` — specifically `StatementSync.columns()` (added
+* in Node 22.16.0 / 23.11.0).
+*
+* @see https://github.com/nodejs/node/pull/57490
+*/
+const checkNodeSqliteCompat = () => {
+	const parts = process.versions.node.split(".").map(Number);
+	const major = parts[0] ?? 0;
+	const minor = parts[1] ?? 0;
+	if (!(major === 22 && minor >= 16 || major === 23 && minor >= 11 || major >= 24)) return die(`Node.js ${process.versions.node} is missing required node:sqlite APIs (StatementSync.columns). Upgrade to Node.js >=22.16, >=23.11, or >=24.`);
+	return void_;
+};
+const makeWithDatabase = (options, openDatabase) => gen(function* () {
+	yield* checkNodeSqliteCompat();
+	const compiler = makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = gen(function* () {
+		const scope$1 = yield* scope;
+		const db = openDatabase();
+		yield* addFinalizer(scope$1, sync(() => db.close()));
+		const statementReaderCache = /* @__PURE__ */ new WeakMap();
+		const hasRows = (statement) => {
+			const cached = statementReaderCache.get(statement);
+			if (cached !== void 0) return cached;
+			const value = statement.columns().length > 0;
+			statementReaderCache.set(statement, value);
+			return value;
+		};
+		const prepareCache = yield* make$4({
+			capacity: options.prepareCacheSize ?? 200,
+			timeToLive: options.prepareCacheTTL ?? minutes(10),
+			lookup: (sql) => try_({
+				try: () => db.prepare(sql),
+				catch: (cause) => new SqlError({
+					cause,
+					message: "Failed to prepare statement"
+				})
+			})
+		});
+		const runStatement = (statement, params, raw) => withFiber((fiber) => {
+			statement.setReadBigInts(Boolean(get(fiber.services, SafeIntegers)));
+			try {
+				if (hasRows(statement)) return succeed(statement.all(...params));
+				const result = statement.run(...params);
+				return succeed(raw ? result : []);
+			} catch (cause) {
+				return fail(new SqlError({
+					cause,
+					message: "Failed to execute statement"
+				}));
+			}
+		});
+		const run = (sql, params, raw = false) => flatMap(get$1(prepareCache, sql), (s) => runStatement(s, params, raw));
+		const runValues = (sql, params) => acquireUseRelease(get$1(prepareCache, sql), (statement) => try_({
+			try: () => {
+				if (hasRows(statement)) {
+					statement.setReturnArrays(true);
+					return statement.all(...params);
+				}
+				statement.run(...params);
+				return [];
+			},
+			catch: (cause) => new SqlError({
+				cause,
+				message: "Failed to execute statement"
+			})
+		}), (statement) => sync(() => {
+			if (hasRows(statement)) statement.setReturnArrays(false);
+		}));
+		return identity({
+			execute(sql, params, rowTransform) {
+				return rowTransform ? map(run(sql, params), rowTransform) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params, true);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, rowTransform) {
+				const effect = runStatement(db.prepare(sql), params ?? [], false);
+				return rowTransform ? map(effect, rowTransform) : effect;
+			},
+			executeStream(_sql, _params) {
+				return die$1("executeStream not implemented");
+			}
+		});
+	});
+	const semaphore = yield* make$1(1);
+	const connection = yield* makeConnection;
+	return yield* make$2({
+		acquirer: semaphore.withPermits(1)(succeed(connection)),
+		compiler,
+		transactionAcquirer: uninterruptibleMask((restore) => {
+			const scope = getUnsafe(getCurrent().services, Scope);
+			return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope, semaphore.release(1))), connection);
+		}),
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	});
+});
+const make = (options) => makeWithDatabase(options, () => new DatabaseSync(options.filename, {
+	readOnly: options.readonly ?? false,
+	allowExtension: options.allowExtension ?? false
+}));
+const makeMemory = (config = {}) => makeWithDatabase({
+	...config,
+	filename: ":memory:",
+	readonly: false
+}, () => {
+	return new DatabaseSync(":memory:", { allowExtension: config.allowExtension ?? false });
+});
+const layerConfig = (config) => effectServices(unwrap(config).asEffect().pipe(flatMap(make), map((client) => make$3(SqliteClient, client).pipe(add(SqlClient, client))))).pipe(provide(layer$1));
+const layer = (config) => effectServices(map(make(config), (client) => make$3(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer$1));
+const layerMemory = (config = {}) => effectServices(map(makeMemory(config), (client) => make$3(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer$1));
+//#endregion
+export { SqliteClient, TypeId, layer, layerConfig, layerMemory };
+
+//# sourceMappingURL=NodeSqliteClient-BMOt9qz2.mjs.map