From Discord: Resolving Kysely Integration Issues in Effect with SqlResolver

[effect-bot]

Summary

Summary

Issue Encountered:

• User xesrevinu encountered an error (Proxy Magic) while using Kysely integration with SqlResolver in Effect.
• The error was temporarily resolved by wrapping the database query in Effect.suspend.

Reproduction:

• A minimal reproduction of the issue was provided using Vitest for testing in the Effect repository.

Resolution:

• User ecyrbedev identified the issue as related to the proxy not whitelisting the compile method.
• A fix was implemented and a PR was created and merged directly into the next-minor branch.

Additional Issue:

• User xesrevinu identified another scenario requiring handling of Hash.symbol to avoid a TypeError when using Effect.annotateLogs.

Key Takeaways

1. Proxy Whitelisting:

   • Ensure all necessary methods (like compile) are whitelisted in the proxy to avoid runtime errors.

2. Auto-Merge Behavior:

   • Be cautious with PR titles and branches to avoid unexpected auto-merges.
   • Confirm if auto-merge is enabled and understand its behavior in the repository.

3. Handling Special Symbols:

   • Additional handling may be required for special symbols like Hash.symbol to ensure proper functionality and avoid TypeError.

4. Community Collaboration:

   • Effective communication and collaboration (e.g., minimal repros, quick fixes) are crucial for resolving issues efficiently in open-source projects.

5. Testing and Validation:

   • Use testing frameworks like Vitest to create minimal reproductions and validate fixes before merging changes.

By addressing these points, the Effect-TS ecosystem can improve its robustness and developer experience.

Discord thread

https://discord.com/channels/795981131316985866/1262774065819811983

[ecyrbe]

I'll add more tests to cover more use cases, and add corresponding proxy whitelisting

[johanneskares]

Proxy invariant violation: effectifyWith fails for non-configurable properties

Bug Description

When using @effect/sql-kysely with Effect.fn, a TypeError is thrown due to JavaScript Proxy invariant violations. The error occurs because the effectifyWith proxy handler doesn't properly pass through non-configurable properties.

Error Messages

TypeError: 'get' on proxy: property 'Symbol(effect/Hash)' is a read-only and non-configurable data property on the proxy target but the proxy did not return its actual value

TypeError: 'get' on proxy: property 'node' is a read-only and non-configurable data property on the proxy target but the proxy did not return its actual value

Root Cause

The effectifyWith function in @effect/sql-kysely creates a Proxy that wraps Kysely query builders to make them Effect-compatible. However, the proxy's get handler violates a fundamental JavaScript Proxy invariant:

If the target object property is a non-configurable, non-writable data property, the proxy's get trap must return the same value as the target property.

The current implementation recursively wraps all property accesses, including:

1. Symbol properties (like Symbol(effect/Hash))
2. Non-configurable properties (like node on Kysely's internal AST)

When Effect.fn internally compares or hashes the returned value, it accesses these Symbol properties. The proxy returns a wrapped version instead of the actual value, triggering the invariant violation.

Reproduction

import { Effect } from "effect";
import { SqlKysely } from "@effect/sql-kysely";

// This works fine
const workingQuery = Effect.gen(function* () {
  const db = yield* SqlKysely;
  return yield* db.selectFrom("users").selectAll();
});

// This fails with proxy invariant violation
const brokenQuery = Effect.fn("brokenQuery")(function* () {
  const db = yield* SqlKysely;
  return yield* db.selectFrom("users").selectAll();
});

The bug only manifests when using Effect.fn because it performs internal operations (like hashing for tracing) that access Symbol properties on the returned Effect.

Current Implementation

The current effectifyWith function in @effect/sql-kysely/src/internal/patch.ts:

function effectifyWith(
  obj: any,
  commit: () => Effect.Effect<ReadonlyArray<unknown>, SqlError>,
  whitelist: Array<string>
) {
  if (typeof obj !== "object" || obj === null) {
    return obj
  }
  return new Proxy(obj, {
    get(target, prop): any {
      const prototype = Object.getPrototypeOf(target)
      if (Effect.EffectTypeId in prototype && prop === "commit") {
        return commit.bind(target)
      }
      if (typeof (target[prop]) === "function") {
        if (typeof prop === "string" && whitelist.includes(prop)) {
          return target[prop].bind(target)
        }
        return (...args: Array<any>) => effectifyWith(target[prop].call(target, ...args), commit, whitelist)
      }
      return effectifyWith(target[prop], commit, whitelist)
    }
  })
}

The problem is on line return effectifyWith(target[prop], commit, whitelist) - it recursively wraps all property accesses, including Symbol properties and non-configurable properties, which violates Proxy invariants.

Proposed Fix

Modify the effectifyWith proxy handler to properly pass through:

1. All Symbol properties directly
2. Non-configurable properties without wrapping

function effectifyWith<A>(
  value: A,
  commit: (this: A) => Effect.Effect<unknown, unknown, unknown>,
  whitelist: ReadonlyArray<string>
): A {
  if (typeof value !== "object" || value === null) {
    return value;
  }
  return new Proxy(value, {
    get(target, prop): unknown {
      // Pass through Symbol properties directly (required for Effect internals)
      if (typeof prop === "symbol") {
        return (target as Record<symbol, unknown>)[prop];
      }
      
      // Check for non-configurable properties and return them directly
      // This is REQUIRED by JavaScript Proxy invariants
      const descriptor = Object.getOwnPropertyDescriptor(target, prop);
      if (descriptor && !descriptor.configurable) {
        return (target as Record<string, unknown>)[prop];
      }
      
      // Rest of the existing logic...
      const prototype = Object.getPrototypeOf(target);
      if (Effect.EffectTypeId in prototype && prop === "commit") {
        return commit.bind(target);
      }
      const value = (target as Record<string, unknown>)[prop];
      if (typeof value === "function") {
        if (whitelist.includes(prop)) {
          return value.bind(target);
        }
        return (...args: unknown[]) =>
          effectifyWith(
            (value as (...a: unknown[]) => unknown).call(target, ...args),
            commit,
            whitelist
          );
      }
      return effectifyWith(value, commit, whitelist);
    },
  }) as A;
}

Environment

• @effect/sql-kysely: (affected versions)
• effect: 3.x
• kysely: 0.27.x
• Runtime: Bun / Node.js

Workaround

Until this is fixed, you can:

1. Avoid Effect.fn: Use plain functions returning Effect.gen instead
2. Create a custom Kysely service: Implement your own effectifyWith with the fix above

Related

• JavaScript Proxy invariants: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/Proxy/get#invariants