pyfect-dev 0.1.0__py3-none-any.whl

pyfect/sql/mssql/_tds_params.py

@@ -0,0 +1,155 @@
+"""Parameters as pytds sends them: each ``DataType`` as a pytds SQL type,
+sized as tedious sizes it, and each value in the form its serializer
+takes."""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Callable
+from datetime import UTC, date, datetime
+from decimal import Decimal
+from typing import Any, cast
+
+from pytds import tds_types  # pyright: ignore[reportMissingTypeStubs]
+
+from pyfect.sql.mssql._driver import TypedValue
+from pyfect.sql.mssql.types import DataTypeName, ParameterOptions
+
+_DEFAULT_PRECISION = 18
+_DEFAULT_SCALE = 0
+_DEFAULT_TIME_SCALE = 7
+
+
+def _utf16_units(text: str) -> int:
+    """``text``'s length as JavaScript counts it (UTF-16 code units), the
+    unit SQL Server sizes ``NVARCHAR`` in."""
+    return len(text.encode("utf-16-le", "surrogatepass")) // 2
+
+
+def _length(options: ParameterOptions, value: object, maximum: int) -> int | None:
+    """The length tedious gives the type: the options', else the value's
+    (at least 1), else the type's ``maximum`` (a null, as an output
+    parameter's); ``None`` for ``MAX``."""
+    if options.length == "max":
+        return None
+    if options.length is not None:
+        return options.length
+    if value is None:
+        return maximum
+    if isinstance(value, memoryview):
+        return cast("memoryview[int]", value).nbytes or 1
+    if isinstance(value, bytes | bytearray):
+        return len(value) or 1
+    size = _utf16_units(value if isinstance(value, str) else str(value))
+    return size or 1
+
+
+def _variable(
+    sized: Callable[[int], Any], unbounded: Callable[[], Any], maximum: int
+) -> Callable[[ParameterOptions, object], Any]:
+    def make(options: ParameterOptions, value: object) -> Any:
+        length = _length(options, value, maximum)
+        return unbounded() if length is None or length > maximum else sized(length)
+
+    return make
+
+
+def _fixed(sized: Callable[[int], Any], maximum: int) -> Callable[[ParameterOptions, object], Any]:
+    return lambda options, value: sized(_length(options, value, maximum) or maximum)
+
+
+def _plain(make: Callable[[], Any]) -> Callable[[ParameterOptions, object], Any]:
+    return lambda _options, _value: make()
+
+
+def _decimal(options: ParameterOptions, _value: object) -> Any:
+    return tds_types.DecimalType(
+        precision=options.precision or _DEFAULT_PRECISION,
+        scale=_DEFAULT_SCALE if options.scale is None else options.scale,
+    )
+
+
+def _scaled(make: Callable[[int], Any]) -> Callable[[ParameterOptions, object], Any]:
+    return lambda options, _value: make(
+        _DEFAULT_TIME_SCALE if options.scale is None else options.scale
+    )
+
+
+_SQL_TYPES: dict[DataTypeName, Callable[[ParameterOptions, object], Any]] = {
+    "Bit": _plain(tds_types.BitType),
+    "TinyInt": _plain(tds_types.TinyIntType),
+    "SmallInt": _plain(tds_types.SmallIntType),
+    "Int": _plain(tds_types.IntType),
+    "BigInt": _plain(tds_types.BigIntType),
+    "Real": _plain(tds_types.RealType),
+    "Float": _plain(tds_types.FloatType),
+    "SmallMoney": _plain(tds_types.SmallMoneyType),
+    "Money": _plain(tds_types.MoneyType),
+    "Decimal": _decimal,
+    "Numeric": _decimal,
+    "Char": _fixed(tds_types.CharType, 8000),
+    "VarChar": _variable(tds_types.VarCharType, tds_types.VarCharMaxType, 8000),
+    "NChar": _fixed(tds_types.NCharType, 4000),
+    "NVarChar": _variable(tds_types.NVarCharType, tds_types.NVarCharMaxType, 4000),
+    "Text": _plain(tds_types.TextType),
+    "NText": _plain(tds_types.NTextType),
+    "Binary": _fixed(tds_types.BinaryType, 8000),
+    "VarBinary": _variable(tds_types.VarBinaryType, tds_types.VarBinaryMaxType, 8000),
+    "Image": _plain(tds_types.ImageType),
+    "UniqueIdentifier": _plain(tds_types.UniqueIdentifierType),
+    "Xml": _plain(tds_types.XmlType),
+    "Date": _plain(tds_types.DateType),
+    "Time": _scaled(lambda scale: tds_types.TimeType(precision=scale)),
+    "SmallDateTime": _plain(tds_types.SmallDateTimeType),
+    "DateTime": _plain(tds_types.DateTimeType),
+    "DateTime2": _scaled(lambda scale: tds_types.DateTime2Type(precision=scale)),
+    "DateTimeOffset": _scaled(lambda scale: tds_types.DateTimeOffsetType(precision=scale)),
+}
+
+_TEXT: frozenset[DataTypeName] = frozenset(
+    {"Char", "VarChar", "NChar", "NVarChar", "Text", "NText", "Xml"}
+)
+_BINARY: frozenset[DataTypeName] = frozenset({"Binary", "VarBinary", "Image"})
+_DECIMAL: frozenset[DataTypeName] = frozenset({"Decimal", "Numeric", "SmallMoney", "Money"})
+_UTC_WALL_CLOCK: frozenset[DataTypeName] = frozenset({"SmallDateTime", "DateTime", "DateTime2"})
+
+
+def _value(name: DataTypeName, value: object) -> object:  # noqa: PLR0911
+    """``value`` as the serializer of ``name`` takes it. As tedious (with
+    ``useUTC``), an aware datetime is sent as its UTC wall clock, and a
+    naive one as a UTC time for ``DateTimeOffset``."""
+    if value is None:
+        return None
+    if name in _TEXT and not isinstance(value, str):
+        return str(value)
+    if name in _BINARY and isinstance(value, bytearray):
+        return bytes(value)
+    if name in _BINARY and isinstance(value, memoryview):
+        return cast("memoryview[int]", value).tobytes()
+    if name in _DECIMAL and isinstance(value, int | float) and not isinstance(value, bool):
+        return Decimal(str(value))
+    if name == "UniqueIdentifier" and isinstance(value, str):
+        return uuid.UUID(value)
+    if isinstance(value, datetime):
+        if name in _UTC_WALL_CLOCK and value.tzinfo is not None:
+            return value.astimezone(UTC).replace(tzinfo=None)
+        if name == "DateTimeOffset" and value.tzinfo is None:
+            return value.replace(tzinfo=UTC)
+        if name == "Date":
+            return value.date()
+    if name in _UTC_WALL_CLOCK and type(value) is date:
+        return datetime(value.year, value.month, value.day)
+    return value
+
+
+def sql_type(parameter: TypedValue) -> Any:
+    """The pytds SQL type ``parameter`` is declared as."""
+    return _SQL_TYPES[parameter.type.name](parameter.options, parameter.value)
+
+
+def value(parameter: TypedValue) -> object:
+    """The value of ``parameter`` as pytds writes it."""
+    return _value(parameter.type.name, parameter.value)
+
+
+__all__ = ["sql_type", "value"]

pyfect/sql/mssql/_worker.py

@@ -0,0 +1,155 @@
+"""The thread a SQL Server connection's blocking calls run on.
+
+Each connection gets one worker thread: its calls run there in the order
+sent while the fiber that sent one waits without blocking others.
+Interrupting the fiber drops a call that has not started; one that has
+gets ``cancel`` (called while it runs, never after) and the fiber waits
+for it to end, so the connection is never used by two calls at once. A
+call given ``release`` (one that opens something, with nothing else to
+protect yet) is left to finish on the thread instead. When a call ends,
+its ``Cancellable`` forgets any cancel asked for it, under the same lock,
+so a cancel that came after its request ended never reaches the next
+call's. A call after ``shutdown`` fails with an ``SqlError`` saying so.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Literal, Protocol
+
+from pyfect._core import Effect, _FailCause, _Succeed, _Suspend
+from pyfect._released import Lifetime, Released
+from pyfect.cause import die, fail, interrupt
+from pyfect.process._os import Latch
+from pyfect.sql.error import SqlError, UnknownError
+
+type _Phase = Literal["queued", "running", "dropped", "abandoned", "done"]
+
+
+def _outcome[A](
+    thunk: Callable[[], A], catch: Callable[[Exception], SqlError]
+) -> Effect[A, SqlError]:
+    """``thunk()`` as an effect; never raises."""
+    try:
+        return _Succeed(thunk())
+    except Exception as exc:
+        try:
+            return _FailCause(fail(catch(exc)))
+        except BaseException as defect:
+            return _FailCause(die(defect))
+    except BaseException as defect:
+        return _FailCause(die(defect))
+
+
+class Cancellable(Protocol):
+    """What an interrupted call is cancelled through."""
+
+    def cancel(self) -> None:
+        """Stop the call's request: in flight, or about to be sent."""
+        ...
+
+    def forget_cancel(self) -> None:
+        """The call ended: a cancel asked for it no longer applies."""
+        ...
+
+
+class _Call[A]:
+    """One call's progress; ``phase`` changes under ``lock``."""
+
+    __slots__ = ("lock", "phase", "settled")
+
+    def __init__(self) -> None:
+        self.lock = threading.Lock()
+        self.phase: _Phase = "queued"
+        self.settled: Latch[Effect[A, SqlError]] = Latch(waits_for="work")
+
+    def end(self) -> bool:
+        """The call ended; whether its fiber had stopped waiting for it."""
+        abandoned = self.phase == "abandoned"
+        self.phase = "done"
+        return abandoned
+
+
+class Worker:
+    """One thread running a connection's calls in order."""
+
+    __slots__ = ("_executor", "_lifetime")
+
+    def __init__(self) -> None:
+        self._executor = ThreadPoolExecutor(1, thread_name_prefix="pyfect-mssql")
+        self._lifetime = Lifetime("SQL Server connection")
+
+    def call[A](
+        self,
+        thunk: Callable[[], A],
+        catch: Callable[[Exception], SqlError],
+        cancel: Cancellable | None = None,
+        release: Callable[[A], None] | None = None,
+    ) -> Effect[A, SqlError]:
+        """Run ``thunk`` on the thread; an exception it raises fails with
+        ``catch`` of it. Interrupted while it runs, ``cancel`` runs and the
+        fiber waits for ``thunk`` to end. With ``release`` the fiber does not
+        wait: a value ``thunk`` makes all the same goes to ``release``."""
+
+        def start() -> Effect[A, SqlError]:
+            call: _Call[A] = _Call()
+
+            def run() -> None:
+                with call.lock:
+                    if call.phase == "dropped":
+                        call.settled.set(_FailCause(interrupt()))
+                        return
+                    call.phase = "running"
+                outcome = _outcome(thunk, catch)
+                with call.lock:
+                    abandoned = call.end()
+                    if cancel is not None:
+                        cancel.forget_cancel()
+                call.settled.set(outcome)
+                if abandoned:
+                    made(outcome)
+
+            def made(outcome: Effect[A, SqlError]) -> None:
+                if release is not None and isinstance(outcome, _Succeed):
+                    release(outcome.value)
+
+            def released(done: Future[None]) -> None:
+                error = done.exception()
+                if isinstance(error, Released):
+                    reason = UnknownError(cause=error, message=str(error))
+                    call.settled.set(_FailCause(fail(SqlError(reason=reason))))
+
+            self._lifetime.submit(lambda: self._executor.submit(run)).add_done_callback(released)
+
+            def interrupted() -> Effect[None]:
+                with call.lock:
+                    if call.phase == "queued":
+                        call.phase = "dropped"
+                        return _Succeed(None)
+                    if call.phase == "running":
+                        if release is not None:
+                            call.phase = "abandoned"
+                            return _Succeed(None)
+                        if cancel is not None:
+                            cancel.cancel()
+
+                return call.settled.wait().map(made)
+
+            return (
+                call.settled.wait()
+                .flat_map(lambda outcome: outcome)
+                .on_interrupt(_Suspend(interrupted))
+            )
+
+        return _Suspend(start)
+
+    def shutdown(self) -> None:
+        """Stop the thread once its queued calls ran."""
+        self._lifetime.close()
+        self._executor.shutdown(wait=False)
+
+
+__all__ = ["Cancellable", "Worker"]

pyfect/sql/mssql/client.py

@@ -0,0 +1,344 @@
+"""The SQL Server client (Effect's ``@effect/sql-mssql`` ``MssqlClient``):
+an ``SqlClient`` on a pool of pytds connections, with typed parameters
+(``param``) and stored procedure calls (``call``).
+
+``make`` opens the pool and checks it with ``SELECT 1`` (within
+``connect_timeout``, five seconds by default); statements outside a
+transaction each take a connection for themselves, a transaction keeps
+one until it ends, and its savepoints are never released (SQL Server has
+no ``RELEASE SAVEPOINT``). Streams are not implemented, as in Effect::
+
+    program.pipe(fx.provide(mssql.layer(mssql.MssqlClientConfig(server="localhost", ...))))
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from typing import Any, Never, Unpack, cast
+
+from pyfect._core import Effect
+from pyfect._effect_args import require_effect
+from pyfect.config import Config, ConfigError, unwrap
+from pyfect.context import Context, Tag
+from pyfect.effect import fail
+from pyfect.layer import Layer, provide
+from pyfect.layer import effect_context as layer_effect_context
+from pyfect.reactivity import Reactivity
+from pyfect.reactivity import layer as reactivity_layer
+from pyfect.redacted import value as redacted_value
+from pyfect.scope import Scope, scoped
+from pyfect.sql.client import (
+    ClientFields,
+    SqlClient,
+    SqlClientService,
+    TransactionOptions,
+    make_with_transaction,
+    transaction_connection,
+)
+from pyfect.sql.client import make as make_sql_client
+from pyfect.sql.connection import Connection
+from pyfect.sql.error import ConnectionError, SqlError
+from pyfect.sql.mssql import _pool
+from pyfect.sql.mssql._connection import MssqlConnection, is_mssql_param, mssql_param
+from pyfect.sql.mssql._driver import ConnectOptions
+from pyfect.sql.mssql._names import escape
+from pyfect.sql.mssql.config import (
+    DEFAULT_CANCEL_TIMEOUT,
+    DEFAULT_CHECK_TIMEOUT,
+    DEFAULT_CONNECT_TIMEOUT,
+    DEFAULT_CONNECTION_RETRY_INTERVAL,
+    DEFAULT_CONNECTION_TTL,
+    DEFAULT_MAX_CONNECTIONS,
+    DEFAULT_MAX_RETRIES_ON_TRANSIENT_ERRORS,
+    DEFAULT_MIN_CONNECTIONS,
+    DEFAULT_PORT,
+    MssqlClientConfig,
+    driver_seconds_or,
+    seconds_or,
+)
+from pyfect.sql.mssql.error import classify
+from pyfect.sql.mssql.procedure import ProcedureWithValues, Result
+from pyfect.sql.mssql.types import DataType, ParameterOptions
+from pyfect.sql.statement import (
+    Compiled,
+    Compiler,
+    Custom,
+    Fragment,
+    Placeholder,
+    default_transforms,
+)
+from pyfect.sql.statement import make_compiler as make_statement_compiler
+
+
+class MssqlClientService(SqlClientService):
+    """A SQL Server client: an ``SqlClientService``, its config, typed
+    parameters and stored procedure calls."""
+
+    __slots__ = ("config",)
+
+    config: MssqlClientConfig
+
+    def __init__(self, *, config: MssqlClientConfig, **fields: Unpack[ClientFields]) -> None:
+        super().__init__(**fields)
+        self.config = config
+
+    def param(
+        self,
+        type: DataType,
+        value: object,
+        options: ParameterOptions | None = None,
+    ) -> Fragment:
+        """A parameter sent as ``type`` (``client.param(TYPES.BigInt, 1)``)."""
+        return Fragment((mssql_param(type, value, options or ParameterOptions()),))
+
+    def call[A](self, procedure: ProcedureWithValues[A]) -> Effect[Result[A], SqlError]:
+        """Run a stored procedure (on the transaction's connection inside
+        one): its output parameters and rows, renamed as the client renames
+        results."""
+        transform_rows = self.transform_rows
+        return scoped(
+            self.acquirer.flat_map(
+                lambda conn: cast("MssqlConnection", conn).call(procedure, transform_rows)
+            )
+        )
+
+
+class MssqlClient(Tag[MssqlClientService], key="@effect/sql-mssql/MssqlClient"):
+    """The SQL Server client service."""
+
+
+def _on_insert(
+    columns: Sequence[str],
+    placeholders: str,
+    values: Sequence[Sequence[object]],
+    returning: Compiled | None,
+) -> Compiled:
+    output = ""
+    binds: list[object] = []
+    if returning is not None:
+        output = " OUTPUT INSERTED.*" if returning[0] == "*" else f" OUTPUT {returning[0]}"
+        binds.extend(returning[1])
+    for row in values:
+        binds.extend(row)
+    return (f"({','.join(columns)}){output} VALUES {placeholders}", tuple(binds))
+
+
+def _on_record_update(
+    placeholders: str,
+    alias: str,
+    columns: str,
+    values: Sequence[Sequence[object]],
+    returning: Compiled | None,
+) -> Compiled:
+    output = ""
+    binds: list[object] = []
+    if returning is not None:
+        output = "OUTPUT INSERTED.* " if returning[0] == "*" else f"OUTPUT {returning[0]} "
+        binds.extend(returning[1])
+    for row in values:
+        binds.extend(row)
+    return (f"{output}FROM (values {placeholders}) AS {alias}{columns}", tuple(binds))
+
+
+def _on_custom(
+    segment: Custom[Any, Any, Any, Any], placeholder: Placeholder, _without_transform: bool
+) -> Compiled:
+    if is_mssql_param(segment):
+        return (placeholder(None), (segment,))
+    return ("", ())
+
+
+def make_compiler(transform: Callable[[str], str] | None = None) -> Compiler:
+    """SQL Server's compiler: ``@1``, ``@2``, ... placeholders, ``[quoted]``
+    names (renamed with ``transform`` unless a statement runs without
+    transforms) and ``OUTPUT INSERTED`` for ``returning``."""
+
+    def on_identifier(value: str, without_transform: bool) -> str:
+        if transform is None or without_transform:
+            return escape(value)
+        return escape(transform(value))
+
+    return make_statement_compiler(
+        dialect="mssql",
+        placeholder=lambda index, _value: f"@{index}",
+        on_identifier=on_identifier,
+        on_record_update=_on_record_update,
+        on_custom=_on_custom,
+        on_insert=_on_insert,
+    )
+
+
+def connect_options(config: MssqlClientConfig) -> ConnectOptions:
+    """What the driver connects with, for ``config``."""
+    retries = config.max_retries_on_transient_errors
+    return ConnectOptions(
+        server=config.server,
+        port=config.port if config.port is not None or config.instance_name else DEFAULT_PORT,
+        instance_name=config.instance_name,
+        database=config.database,
+        username=config.username,
+        password=None if config.password is None else redacted_value(config.password),
+        encrypt=config.encrypt,
+        trust_server=config.trust_server,
+        connect_timeout=driver_seconds_or(config.connect_timeout, DEFAULT_CONNECT_TIMEOUT),
+        cancel_timeout=driver_seconds_or(config.cancel_timeout, DEFAULT_CANCEL_TIMEOUT),
+        connection_retry_interval=driver_seconds_or(
+            config.connection_retry_interval, DEFAULT_CONNECTION_RETRY_INTERVAL
+        ),
+        max_retries_on_transient_errors=DEFAULT_MAX_RETRIES_ON_TRANSIENT_ERRORS
+        if retries is None
+        else retries,
+    )
+
+
+def _span_attributes(config: MssqlClientConfig) -> list[tuple[str, object]]:
+    return [
+        *config.span_attributes.items(),
+        ("db.system.name", "microsoft.sql_server"),
+        ("db.namespace", config.database or "master"),
+        ("server.address", config.server),
+        ("server.port", config.port or DEFAULT_PORT),
+    ]
+
+
+def _connect_failed(error: SqlError) -> SqlError:
+    return SqlError(
+        reason=classify(
+            error,
+            message="MssqlClient: Failed to connect",
+            operation="connect",
+            fallback="connection",
+        )
+    )
+
+
+def _connect_timed_out() -> Effect[Never, SqlError]:
+    return fail(
+        SqlError(
+            reason=ConnectionError(
+                cause=Exception("connection timeout"),
+                message="MssqlClient: Connection timeout",
+                operation="connect",
+            )
+        )
+    )
+
+
+def make(config: MssqlClientConfig) -> Effect[MssqlClientService, SqlError, Scope | Reactivity]:
+    """A client on a pool of connections; it closes with the scope."""
+    pool = _pool.make(
+        connect_options(config),
+        config.parameter_types,
+        min_connections=DEFAULT_MIN_CONNECTIONS
+        if config.min_connections is None
+        else config.min_connections,
+        max_connections=config.max_connections or DEFAULT_MAX_CONNECTIONS,
+        ttl=seconds_or(config.connection_ttl, DEFAULT_CONNECTION_TTL),
+    )
+    span_attributes = _span_attributes(config)
+
+    def build(
+        check_out: Effect[MssqlConnection, SqlError, Scope],
+    ) -> Effect[MssqlClientService, SqlError, Reactivity]:
+        acquirer = cast("Effect[Connection, SqlError, Scope]", check_out)
+        connected = (
+            scoped(
+                acquirer.flat_map(
+                    lambda conn: conn.execute_unprepared("SELECT 1", (), None)
+                ).map_error(_connect_failed)
+            )
+            .timeout_or_else(
+                seconds_or(config.connect_timeout, DEFAULT_CHECK_TIMEOUT), _connect_timed_out
+            )
+            .as_void()
+        )
+        transform_rows = (
+            None
+            if config.transform_result_names is None
+            else default_transforms(config.transform_result_names).array
+        )
+        service = transaction_connection()
+
+        def mssql(conn: Connection) -> MssqlConnection:
+            return cast("MssqlConnection", conn)
+
+        with_transaction = make_with_transaction(
+            TransactionOptions(
+                transaction_service=service,
+                span_attributes=tuple(span_attributes),
+                acquire_connection=lambda restore: restore(acquirer),
+                begin=lambda conn, _statement: mssql(conn).begin,
+                savepoint=lambda conn, depth: mssql(conn).savepoint(f"effect_sql_{depth}"),
+                commit=lambda conn: mssql(conn).commit,
+                rollback=lambda conn: mssql(conn).rollback(),
+                rollback_savepoint=lambda conn, depth: mssql(conn).rollback(f"effect_sql_{depth}"),
+            )
+        )
+        client = make_sql_client(
+            driver="mssql",
+            acquirer=acquirer,
+            compiler=make_compiler(config.transform_query_names),
+            transaction_service=service,
+            span_attributes=span_attributes,
+            transform_rows=transform_rows,
+        )
+
+        def finish(c: SqlClientService) -> MssqlClientService:
+            fields = c.fields()
+            fields["with_transaction"] = with_transaction
+            return MssqlClientService(config=config, **fields)
+
+        return connected.and_then(client.map(finish))
+
+    return pool.flat_map(build)
+
+
+def _contexts(client: MssqlClientService) -> Context[MssqlClient | SqlClient]:
+    return Context.empty().add(MssqlClient, client).add(SqlClient, client)
+
+
+def layer_from[E](
+    acquire: Effect[MssqlClientService, E, Scope | Reactivity],
+) -> Layer[MssqlClient | SqlClient, E]:
+    """Provides the client ``acquire`` makes as ``MssqlClient`` and
+    ``SqlClient``, with its own ``Reactivity``."""
+    require_effect(acquire, "acquire")
+    return layer_effect_context(acquire.map(_contexts)).pipe(provide(reactivity_layer))
+
+
+def layer(config: MssqlClientConfig) -> Layer[MssqlClient | SqlClient, SqlError]:
+    """Provides a client (``make``)."""
+    return layer_from(make(config))
+
+
+def layer_config(
+    config: Config[MssqlClientConfig] | Mapping[str, Any],
+) -> Layer[MssqlClient | SqlClient, ConfigError | SqlError]:
+    """``layer`` with the config read from the ``ConfigProvider``: a
+    ``Config`` of the whole config, or a mapping from field names to their
+    ``Config`` (Effect's ``Config.Wrap``)::
+
+        mssql.layer_config({
+            "server": fx.config.string("MSSQL_SERVER"),
+            "password": fx.config.redacted("MSSQL_PASSWORD"),
+        })
+    """
+    read: Effect[MssqlClientConfig, ConfigError] = (
+        config
+        if isinstance(config, Config)
+        else unwrap(config).map(lambda fields: MssqlClientConfig(**fields))
+    )
+    return layer_from(read.flat_map(make))
+
+
+__all__ = [
+    "MssqlClient",
+    "MssqlClientService",
+    "SqlError",
+    "connect_options",
+    "layer",
+    "layer_config",
+    "layer_from",
+    "make",
+    "make_compiler",
+]