@das-org/dascode 0.0.31

package/dist/SqlError-D49f1UD-.mjs

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+
+import { F as TaggedErrorClass, M as String, Nt as optional, W as Union, ad as hasProperty, b as Natural, l as Defect } from "./Schema-DuQUv9rO.mjs";
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.102_patch_10dcca2e28a1e6c67a3825e6da1ff253/node_modules/effect/dist/unstable/sql/SqlError.js
+/**
+* Defines structured failures for SQL clients and driver integrations.
+*
+* `SqlError` wraps the different reasons a SQL operation can fail, such as
+* connection, authentication, authorization, syntax, constraint, or transaction
+* problems. Each reason keeps the original cause, optional message and
+* operation metadata, and whether retrying may succeed. This module also
+* includes schemas, guards, a SQLite error classifier, and the
+* `ResultLengthMismatch` error used by ordered batched SQL resolvers.
+*
+* @since 4.0.0
+*/
+const TypeId = "~effect/sql/SqlError";
+const ReasonTypeId = "~effect/sql/SqlError/Reason";
+const ReasonFields = {
+	cause: /*#__PURE__*/ Defect(),
+	message: /*#__PURE__*/ optional(String),
+	operation: /*#__PURE__*/ optional(String)
+};
+/**
+* SQL error reason for connection or open failures; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConnectionError = class extends TaggedErrorClass("effect/sql/SqlError/ConnectionError")("ConnectionError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for authentication failures such as invalid credentials; not
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthenticationError = class extends TaggedErrorClass("effect/sql/SqlError/AuthenticationError")("AuthenticationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for authorization or permission failures; not marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var AuthorizationError = class extends TaggedErrorClass("effect/sql/SqlError/AuthorizationError")("AuthorizationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for invalid SQL syntax; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlSyntaxError = class extends TaggedErrorClass("effect/sql/SqlError/SqlSyntaxError")("SqlSyntaxError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+const UniqueViolationFields = {
+	...ReasonFields,
+	constraint: String
+};
+/**
+* SQL error reason for a unique constraint violation, including the violated
+* constraint identifier; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UniqueViolation = class extends TaggedErrorClass("effect/sql/SqlError/UniqueViolation")("UniqueViolation", UniqueViolationFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a non-unique constraint violation; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var ConstraintError = class extends TaggedErrorClass("effect/sql/SqlError/ConstraintError")("ConstraintError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* SQL error reason for a database deadlock; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var DeadlockError = class extends TaggedErrorClass("effect/sql/SqlError/DeadlockError")("DeadlockError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a transaction serialization or isolation conflict;
+* marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SerializationError = class extends TaggedErrorClass("effect/sql/SqlError/SerializationError")("SerializationError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for timing out while waiting on a database lock; marked
+* retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var LockTimeoutError = class extends TaggedErrorClass("effect/sql/SqlError/LockTimeoutError")("LockTimeoutError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for a statement or query timeout; marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var StatementTimeoutError = class extends TaggedErrorClass("effect/sql/SqlError/StatementTimeoutError")("StatementTimeoutError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return true;
+	}
+};
+/**
+* SQL error reason for an unclassified database failure; not marked retryable.
+*
+* @category errors
+* @since 4.0.0
+*/
+var UnknownError = class extends TaggedErrorClass("effect/sql/SqlError/UnknownError")("UnknownError", ReasonFields) {
+	/**
+	* Marks this value as a structured SQL error reason for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[ReasonTypeId] = ReasonTypeId;
+	/**
+	* Indicates whether retrying the failed SQL operation may succeed.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return false;
+	}
+};
+/**
+* Schema for encoding and decoding SQL error reasons.
+*
+* @category schemas
+* @since 4.0.0
+*/
+const SqlErrorReason = /*#__PURE__*/ Union([
+	ConnectionError,
+	AuthenticationError,
+	AuthorizationError,
+	SqlSyntaxError,
+	UniqueViolation,
+	ConstraintError,
+	DeadlockError,
+	SerializationError,
+	LockTimeoutError,
+	StatementTimeoutError,
+	UnknownError
+]);
+/**
+* Error wrapper for SQL failures whose `message`, `cause`, and `isRetryable`
+* values are derived from its `SqlErrorReason`.
+*
+* @category errors
+* @since 4.0.0
+*/
+var SqlError = class extends TaggedErrorClass("effect/sql/SqlError")("SqlError", { reason: SqlErrorReason }) {
+	/**
+	* Marks this value as the top-level SQL error wrapper for runtime guards.
+	*
+	* @since 4.0.0
+	*/
+	[TypeId] = TypeId;
+	/**
+	* Exposes the structured SQL reason as the JavaScript error cause.
+	*
+	* @since 4.0.0
+	*/
+	cause = this.reason;
+	/**
+	* Uses the reason message when present, otherwise falls back to the reason tag.
+	*
+	* @since 4.0.0
+	*/
+	get message() {
+		return this.reason.message || this.reason._tag;
+	}
+	/**
+	* Delegates retryability to the underlying SQL error reason.
+	*
+	* @since 4.0.0
+	*/
+	get isRetryable() {
+		return this.reason.isRetryable;
+	}
+};
+const sqliteCodeFromCause = (cause) => {
+	if (!hasProperty(cause, "code")) return;
+	const code = cause.code;
+	return typeof code === "string" || typeof code === "number" ? code : void 0;
+};
+const sqliteNumericCodeFromCause = (cause) => {
+	const code = sqliteCodeFromCause(cause);
+	if (typeof code === "number") return code;
+	if (!hasProperty(cause, "errno")) return;
+	const errno = cause.errno;
+	return typeof errno === "number" ? errno : void 0;
+};
+const matchesSqliteNumericCode = (cause, expected) => {
+	if (sqliteCodeFromCause(cause) === expected) return true;
+	if (!hasProperty(cause, "errno")) return false;
+	return cause.errno === expected;
+};
+const matchesSqliteCode = (code, expected) => code === expected || code.startsWith(expected + "_");
+const UNKNOWN_CONSTRAINT = "unknown";
+const SQLITE_CONSTRAINT_UNIQUE = "SQLITE_CONSTRAINT_UNIQUE";
+const SQLITE_CONSTRAINT_UNIQUE_CODE = 2067;
+const normalizeConstraintIdentifier = (identifier) => {
+	if (typeof identifier !== "string") return UNKNOWN_CONSTRAINT;
+	const trimmed = identifier.trim();
+	return trimmed.length === 0 ? UNKNOWN_CONSTRAINT : trimmed;
+};
+const sqliteUniqueConstraintFromCause = (cause) => {
+	if (hasProperty(cause, "constraint")) return normalizeConstraintIdentifier(cause.constraint);
+	if (!hasProperty(cause, "message")) return UNKNOWN_CONSTRAINT;
+	const message = cause.message;
+	if (typeof message !== "string") return UNKNOWN_CONSTRAINT;
+	const index = message.indexOf("UNIQUE constraint failed:");
+	return index === -1 ? UNKNOWN_CONSTRAINT : normalizeConstraintIdentifier(message.slice(index + 25));
+};
+/**
+* Classifies a native SQLite error cause into a `SqlErrorReason` using its
+* `code` or `errno`, with optional message and operation metadata.
+*
+* @category converting
+* @since 4.0.0
+*/
+const classifySqliteError = (cause, { message, operation } = {}) => {
+	const props = {
+		cause,
+		message,
+		operation
+	};
+	const code = sqliteCodeFromCause(cause);
+	const numericCode = sqliteNumericCodeFromCause(cause);
+	if (code === SQLITE_CONSTRAINT_UNIQUE || matchesSqliteNumericCode(cause, SQLITE_CONSTRAINT_UNIQUE_CODE)) return new UniqueViolation({
+		...props,
+		constraint: sqliteUniqueConstraintFromCause(cause)
+	});
+	if (typeof code === "string") {
+		if (matchesSqliteCode(code, "SQLITE_AUTH")) return new AuthenticationError(props);
+		if (matchesSqliteCode(code, "SQLITE_PERM")) return new AuthorizationError(props);
+		if (matchesSqliteCode(code, "SQLITE_CONSTRAINT")) return new ConstraintError(props);
+		if (matchesSqliteCode(code, "SQLITE_BUSY") || matchesSqliteCode(code, "SQLITE_LOCKED")) return new LockTimeoutError(props);
+		if (matchesSqliteCode(code, "SQLITE_CANTOPEN")) return new ConnectionError(props);
+	}
+	if (typeof numericCode === "number") switch (numericCode & 255) {
+		case 23: return new AuthenticationError(props);
+		case 3: return new AuthorizationError(props);
+		case 19: return new ConstraintError(props);
+		case 5:
+		case 6: return new LockTimeoutError(props);
+		case 14: return new ConnectionError(props);
+		default: return new UnknownError(props);
+	}
+	return new UnknownError(props);
+};
+TaggedErrorClass("effect/sql/ResultLengthMismatch")("ResultLengthMismatch", {
+	expected: Natural,
+	actual: Natural
+});
+//#endregion
+export { classifySqliteError as n, SqlError as t };
+
+//# sourceMappingURL=SqlError-D49f1UD-.mjs.map

package/dist/SqliteClient-DEcJdONi.mjs

@@ -0,0 +1,147 @@
+#!/usr/bin/env node
+
+import { Cd as identity, Ea as withFiber, Eo as provide, Gr as flatMap, Jl as add, No as Scope, Po as addFinalizer$1, Xl as get, _r as as, eu as getUnsafe, ha as try_, ii as gen, na as succeed, oa as sync, ql as Service, sa as tap, tu as make$1, ur as addFinalizer, ya as uninterruptibleMask, yi as map, yo as effectContext, zr as fail } from "./Schema-DuQUv9rO.mjs";
+import { Ht as make$2, g as die, vn as getCurrent } from "./Path-BB53LP8h.mjs";
+import { y as unwrap } from "./Config-DcF-IZjO.mjs";
+import { a as makeCompilerSqlite, i as defaultTransforms, n as SqlClient, o as layer$1, r as make$3, t as SafeIntegers } from "./SqlClient-Dp5XVCmr.mjs";
+import { n as classifySqliteError, t as SqlError } from "./SqlError-D49f1UD-.mjs";
+import { Database } from "bun:sqlite";
+//#region ../../node_modules/.pnpm/@effect+sql-sqlite-bun@4.0._83a5bc55a7214d0946731fba94f69989/node_modules/@effect/sql-sqlite-bun/dist/SqliteClient.js
+/**
+* Connects Effect SQL to SQLite when running on Bun, using `bun:sqlite`.
+*
+* This module opens a SQLite database and exposes it as both `SqliteClient` and
+* the generic Effect SQL client. It serializes access to the database, enables
+* WAL mode unless disabled, and supports database export and extension loading.
+* Streaming queries and `updateValues` are not supported by this driver.
+*
+* @since 4.0.0
+*/
+const ATTR_DB_SYSTEM_NAME = "db.system.name";
+const classifyError = (cause, message, operation) => classifySqliteError(cause, {
+	message,
+	operation
+});
+/**
+* Runtime type identifier used to mark Bun `SqliteClient` values.
+*
+* @category type IDs
+* @since 4.0.0
+*/
+const TypeId = "~@effect/sql-sqlite-bun/SqliteClient";
+/**
+* Service tag for the Bun SQLite client service.
+*
+* **When to use**
+*
+* Use to access or provide a Bun SQLite client through the Effect context.
+*
+* @category services
+* @since 4.0.0
+*/
+const SqliteClient = /*#__PURE__*/ Service("@effect/sql-sqlite-bun/Client");
+/**
+* Creates a scoped Bun SQLite client for a database file, enabling WAL by default and serializing access. Streaming queries are not implemented.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const make = (options) => gen(function* () {
+	const compiler = makeCompilerSqlite(options.transformQueryNames);
+	const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : void 0;
+	const makeConnection = gen(function* () {
+		const db = new Database(options.filename, {
+			readonly: options.readonly,
+			readwrite: options.readwrite ?? true,
+			create: options.create ?? true
+		});
+		yield* addFinalizer(() => sync(() => db.close()));
+		if (options.disableWAL !== true) db.run("PRAGMA journal_mode = WAL;");
+		const prepare = (sql, useSafeIntegers) => {
+			const statement = db.query(sql);
+			statement.safeIntegers(useSafeIntegers);
+			return statement;
+		};
+		const run = (sql, params = []) => withFiber((fiber) => {
+			const useSafeIntegers = get(fiber.context, SafeIntegers);
+			try {
+				return succeed(prepare(sql, useSafeIntegers).all(...params) ?? []);
+			} catch (cause) {
+				return fail(new SqlError({ reason: classifyError(cause, "Failed to execute statement", "execute") }));
+			}
+		});
+		const runValues = (sql, params = []) => withFiber((fiber) => {
+			const useSafeIntegers = get(fiber.context, SafeIntegers);
+			try {
+				return succeed(prepare(sql, useSafeIntegers).values(...params) ?? []);
+			} catch (cause) {
+				return fail(new SqlError({ reason: classifyError(cause, "Failed to execute statement", "executeValues") }));
+			}
+		});
+		return identity({
+			execute(sql, params, transformRows) {
+				return transformRows ? map(run(sql, params), transformRows) : run(sql, params);
+			},
+			executeRaw(sql, params) {
+				return run(sql, params);
+			},
+			executeValues(sql, params) {
+				return runValues(sql, params);
+			},
+			executeValuesUnprepared(sql, params) {
+				return runValues(sql, params);
+			},
+			executeUnprepared(sql, params, transformRows) {
+				return this.execute(sql, params, transformRows);
+			},
+			executeStream(_sql, _params) {
+				return die("executeStream not implemented");
+			},
+			export: try_({
+				try: () => db.serialize(),
+				catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to export database", "export") })
+			}),
+			loadExtension: (path) => try_({
+				try: () => db.loadExtension(path),
+				catch: (cause) => new SqlError({ reason: classifyError(cause, "Failed to load extension", "loadExtension") })
+			})
+		});
+	});
+	const semaphore = yield* make$2(1);
+	const connection = yield* makeConnection;
+	const acquirer = semaphore.withPermits(1)(succeed(connection));
+	const transactionAcquirer = uninterruptibleMask((restore) => {
+		const scope = getUnsafe(getCurrent().context, Scope);
+		return as(tap(restore(semaphore.take(1)), () => addFinalizer$1(scope, semaphore.release(1))), connection);
+	});
+	return Object.assign(yield* make$3({
+		acquirer,
+		compiler,
+		transactionAcquirer,
+		spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+		transformRows
+	}), {
+		[TypeId]: TypeId,
+		config: options,
+		export: flatMap(acquirer, (_) => _.export),
+		loadExtension: (path) => flatMap(acquirer, (_) => _.loadExtension(path))
+	});
+});
+/**
+* Creates a layer from a `Config`-wrapped Bun SQLite client configuration, providing both `SqliteClient` and `SqlClient`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layerConfig = (config) => effectContext(unwrap(config).pipe(flatMap(make), map((client) => make$1(SqliteClient, client).pipe(add(SqlClient, client))))).pipe(provide(layer$1));
+/**
+* Creates a layer from a concrete Bun SQLite client configuration, providing both `SqliteClient` and `SqlClient`.
+*
+* @category layers
+* @since 4.0.0
+*/
+const layer = (config) => effectContext(map(make(config), (client) => make$1(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer$1));
+//#endregion
+export { SqliteClient, TypeId, layer, layerConfig, make };
+
+//# sourceMappingURL=SqliteClient-DEcJdONi.mjs.map