@neetru/sdk 2.3.3 → 2.3.5

package/dist/index.cjs

@@ -5,12 +5,6 @@ var idb = require('idb');
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -174,6 +168,405 @@ var init_http = __esm({
   }
 });
 
+// src/db-errors.ts
+var RETRYABLE_CODES2; exports.NeetruDbError = void 0;
+var init_db_errors = __esm({
+  "src/db-errors.ts"() {
+    init_errors();
+    RETRYABLE_CODES2 = /* @__PURE__ */ new Set([
+      "db_unavailable",
+      "db_conflict",
+      "db_timeout"
+    ]);
+    exports.NeetruDbError = class _NeetruDbError extends exports.NeetruError {
+      /** Código de erro fechado — específico de DB. */
+      code;
+      /**
+       * `true` para erros transientes que o produto pode tentar novamente.
+       * São retryable: `db_unavailable`, `db_conflict`, `db_timeout`.
+       */
+      retryable;
+      /**
+       * ID opaco do banco lógico — só para correlação com logs do Core.
+       * Nunca deve ser exibido ao usuário final.
+       */
+      dbId;
+      constructor(code, message, dbId) {
+        super(code, message);
+        this.name = "NeetruDbError";
+        this.code = code;
+        this.retryable = RETRYABLE_CODES2.has(code);
+        this.dbId = dbId;
+        Object.setPrototypeOf(this, _NeetruDbError.prototype);
+      }
+    };
+  }
+});
+
+// src/db/sql/lease.ts
+function mapPoolError(err) {
+  if (err instanceof exports.NeetruDbError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err instanceof Error ? err.code : void 0;
+  if (typeof code === "string" && (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT")) {
+    return new exports.NeetruDbError(
+      "db_unavailable",
+      `Pool connection failed (${code}): ${message}`
+    );
+  }
+  if (message.includes("statement timeout") || message.includes("lock timeout")) {
+    return new exports.NeetruDbError("db_timeout", `Query timeout: ${message}`);
+  }
+  if (message.includes("40001") || message.includes("40P01") || message.includes("deadlock")) {
+    return new exports.NeetruDbError("db_conflict", `Transaction conflict: ${message}`);
+  }
+  if (message.includes("42501") || message.toLowerCase().includes("permission denied")) {
+    return new exports.NeetruDbError("db_permission_denied", `Permission denied: ${message}`);
+  }
+  return new exports.NeetruDbError("db_unavailable", `Database error: ${message}`);
+}
+var RENEWAL_THRESHOLD, MIN_RENEWAL_DELAY_MS, SqlLeaseManager;
+var init_lease = __esm({
+  "src/db/sql/lease.ts"() {
+    init_db_errors();
+    RENEWAL_THRESHOLD = 0.8;
+    MIN_RENEWAL_DELAY_MS = 3e4;
+    SqlLeaseManager = class {
+      _lease;
+      _pool;
+      _orm;
+      _renewalTimer = null;
+      _closed = false;
+      _deps;
+      constructor(lease, pool, orm, deps) {
+        this._lease = lease;
+        this._pool = pool;
+        this._orm = orm;
+        this._deps = {
+          ...deps,
+          now: deps.now ?? (() => Date.now())
+        };
+        this._scheduleRenewal();
+      }
+      // ─── Superfície pública (NeetruSqlClient) ──────────────────────────────────
+      get orm() {
+        this._assertOpen();
+        return this._orm;
+      }
+      async transaction(fn, opts) {
+        this._assertOpen();
+        try {
+          if (opts?.isolationLevel) {
+            return await this._orm.transaction(fn, {
+              isolationLevel: opts.isolationLevel
+            });
+          }
+          return await this._orm.transaction(fn);
+        } catch (err) {
+          throw mapPoolError(err);
+        }
+      }
+      async close() {
+        if (this._closed) return;
+        this._closed = true;
+        this._cancelRenewal();
+        await this._pool.end().catch(() => {
+        });
+      }
+      // ─── Renovação proativa ────────────────────────────────────────────────────
+      /**
+       * Calcula o delay de renovação: momento de ~80% do TTL restante.
+       *
+       * Fórmula: `renewAt = issuedAt + TTL * RENEWAL_THRESHOLD`
+       *   = `expiresAt - TTL * (1 - RENEWAL_THRESHOLD)`
+       *
+       * Se o lease já está além do ponto de renovação (ou TTL não calculável),
+       * usa `MIN_RENEWAL_DELAY_MS` como fallback seguro.
+       */
+      _calcRenewalDelayMs() {
+        const expiresAtMs = Date.parse(this._lease.expiresAt);
+        if (!Number.isFinite(expiresAtMs)) return MIN_RENEWAL_DELAY_MS;
+        const now = this._deps.now();
+        const remainingMs = expiresAtMs - now;
+        if (remainingMs <= 0) return MIN_RENEWAL_DELAY_MS;
+        const renewInMs = remainingMs * (1 - RENEWAL_THRESHOLD);
+        return Math.max(MIN_RENEWAL_DELAY_MS, Math.round(renewInMs));
+      }
+      _scheduleRenewal() {
+        if (this._closed) return;
+        const delayMs = this._calcRenewalDelayMs();
+        this._renewalTimer = setTimeout(() => {
+          void this._doRenew();
+        }, delayMs);
+      }
+      _cancelRenewal() {
+        if (this._renewalTimer !== null) {
+          clearTimeout(this._renewalTimer);
+          this._renewalTimer = null;
+        }
+      }
+      async _doRenew() {
+        if (this._closed) return;
+        try {
+          const renewOpts = {
+            leaseId: this._lease.leaseId
+          };
+          if (this._deps.database !== void 0) {
+            renewOpts.database = this._deps.database;
+          }
+          const newLease = await this._deps.fetchLease(renewOpts);
+          await this._swapPool(newLease);
+        } catch (err) {
+          this._renewalTimer = setTimeout(() => {
+            void this._doRenew();
+          }, MIN_RENEWAL_DELAY_MS);
+          if (process.env["NODE_ENV"] !== "production") {
+            console.warn("[SqlLeaseManager] Lease renewal failed, will retry:", err);
+          }
+          return;
+        }
+        this._scheduleRenewal();
+      }
+      /**
+       * Hot-swap do pool: cria pool novo, atualiza ponteiros, drena pool antigo.
+       *
+       * Exposto como método protegido para testes.
+       */
+      async _swapPool(newLease) {
+        const credRotated = newLease.credentialVersion !== this._lease.credentialVersion;
+        if (!credRotated && newLease.leaseId === this._lease.leaseId) {
+          this._lease = newLease;
+          return;
+        }
+        const newPool = this._deps.createPool(newLease);
+        const newOrm = this._deps.createDrizzle(newPool, this._deps.schema);
+        const oldPool = this._pool;
+        this._lease = newLease;
+        this._pool = newPool;
+        this._orm = newOrm;
+        void oldPool.end().catch(() => {
+        });
+      }
+      // ─── Helpers ───────────────────────────────────────────────────────────────
+      _assertOpen() {
+        if (this._closed) {
+          throw new exports.NeetruDbError(
+            "db_unavailable",
+            "SqlLeaseManager foi fechado \u2014 chame close() apenas no shutdown."
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/db/sql/sql-client.ts
+var sql_client_exports = {};
+__export(sql_client_exports, {
+  LEASE_ENDPOINT: () => LEASE_ENDPOINT,
+  LEASE_RENEW_ENDPOINT: () => LEASE_RENEW_ENDPOINT,
+  createDrizzleHandle: () => createDrizzleHandle,
+  createHttpLeaseFetcher: () => createHttpLeaseFetcher,
+  createPgPool: () => createPgPool,
+  createSqlClientFromConfig: () => createSqlClientFromConfig,
+  createSqlClientWithDeps: () => createSqlClientWithDeps
+});
+function mapEnvToCore(sdkEnv) {
+  if (sdkEnv === "workspace") return "staging";
+  if (sdkEnv === "prod") return "production";
+  return "dev";
+}
+function createHttpLeaseFetcher(config) {
+  return async (opts) => {
+    const { httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+    const isRenewal = Boolean(opts?.leaseId);
+    const path = isRenewal ? LEASE_RENEW_ENDPOINT : LEASE_ENDPOINT;
+    let body;
+    if (isRenewal) {
+      body = { leaseId: opts.leaseId };
+    } else {
+      body = {
+        productId: config.productId ?? "",
+        environment: mapEnvToCore(config.env ?? "prod")
+      };
+      if (opts?.database !== void 0) {
+        body["database"] = opts.database;
+      }
+    }
+    let raw;
+    try {
+      raw = await httpRequest2(config, {
+        method: "POST",
+        path,
+        body,
+        requireAuth: true,
+        // Lease fetch é idempotente do ponto de vista de segurança — retries OK.
+        retries: 2
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new exports.NeetruDbError(
+        "db_unavailable",
+        `Falha ao ${isRenewal ? "renovar" : "obter"} lease SQL: ${msg}`
+      );
+    }
+    return parseLease(raw);
+  };
+}
+function parseLease(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new exports.NeetruDbError("db_unavailable", "Resposta de lease inv\xE1lida (n\xE3o \xE9 objeto).");
+  }
+  const envelope = raw;
+  const leaseObj = envelope["lease"];
+  if (!leaseObj || typeof leaseObj !== "object") {
+    throw new exports.NeetruDbError(
+      "db_unavailable",
+      'Resposta de lease inv\xE1lida: campo "lease" ausente ou n\xE3o \xE9 objeto. O Core retorna { kind, lease: { leaseId, host, ... } }.'
+    );
+  }
+  const r = leaseObj;
+  function req(field, type) {
+    if (typeof r[field] !== type) {
+      throw new exports.NeetruDbError(
+        "db_unavailable",
+        `Campo obrigat\xF3rio "${field}" ausente ou tipo inv\xE1lido na resposta de lease.`
+      );
+    }
+    return r[field];
+  }
+  return {
+    leaseId: req("leaseId", "string"),
+    host: req("host", "string"),
+    port: typeof r["port"] === "number" ? r["port"] : 5433,
+    dbName: req("dbName", "string"),
+    user: req("user", "string"),
+    password: req("password", "string"),
+    sslca: typeof r["sslca"] === "string" ? r["sslca"] : null,
+    clientCert: typeof r["clientCert"] === "string" ? r["clientCert"] : null,
+    clientKey: typeof r["clientKey"] === "string" ? r["clientKey"] : null,
+    credentialVersion: typeof r["credentialVersion"] === "number" ? r["credentialVersion"] : 1,
+    expiresAt: req("expiresAt", "string")
+  };
+}
+async function createPgPool(lease) {
+  const { Pool } = await import('pg');
+  const ssl = lease.sslca ? {
+    ca: lease.sslca,
+    cert: lease.clientCert ?? void 0,
+    key: lease.clientKey ?? void 0,
+    rejectUnauthorized: true
+  } : false;
+  return new Pool({
+    host: lease.host,
+    port: lease.port,
+    database: lease.dbName,
+    user: lease.user,
+    password: lease.password,
+    ssl,
+    max: 3,
+    idleTimeoutMillis: 3e4,
+    connectionTimeoutMillis: 1e4
+  });
+}
+async function createDrizzleHandle(pool, schema) {
+  const { drizzle } = await import('drizzle-orm/node-postgres');
+  return drizzle(pool, { schema });
+}
+async function createSqlClientWithDeps(deps, options) {
+  const depsWithDb = options?.database !== void 0 ? { ...deps, database: options.database } : deps;
+  let lease;
+  try {
+    if (options?.database !== void 0) {
+      lease = await depsWithDb.fetchLease({ database: options.database });
+    } else {
+      lease = await depsWithDb.fetchLease();
+    }
+  } catch (err) {
+    if (err instanceof exports.NeetruDbError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new exports.NeetruDbError("db_unavailable", `Falha ao obter lease inicial: ${msg}`);
+  }
+  let pool;
+  try {
+    pool = depsWithDb.createPool(lease);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new exports.NeetruDbError("db_unavailable", `Falha ao abrir pool: ${msg}`);
+  }
+  let orm;
+  try {
+    orm = depsWithDb.createDrizzle(pool, depsWithDb.schema);
+  } catch (err) {
+    await pool.end().catch(() => {
+    });
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new exports.NeetruDbError("db_unavailable", `Falha ao criar handle Drizzle: ${msg}`);
+  }
+  return new SqlLeaseManager(lease, pool, orm, depsWithDb);
+}
+async function createSqlClientFromConfig(config, schema, options) {
+  const fetchLease = createHttpLeaseFetcher(config);
+  let pgMod;
+  let drizzlePgMod;
+  try {
+    pgMod = await import(
+      /* webpackIgnore: true */
+      'pg'
+    );
+    drizzlePgMod = await import(
+      /* webpackIgnore: true */
+      'drizzle-orm/node-postgres'
+    );
+  } catch (err) {
+    throw new exports.NeetruDbError(
+      "db_unavailable",
+      `[client.db.sql] requer pg + drizzle-orm como peerDependencies do servidor. Instale: npm install pg drizzle-orm. (${err.message})`
+    );
+  }
+  const createPool = (lease) => {
+    const Pool = pgMod.Pool ?? pgMod.default?.Pool;
+    const ssl = lease.sslca ? {
+      ca: lease.sslca,
+      cert: lease.clientCert ?? void 0,
+      key: lease.clientKey ?? void 0,
+      rejectUnauthorized: true
+    } : false;
+    return new Pool({
+      host: lease.host,
+      port: lease.port,
+      database: lease.dbName,
+      user: lease.user,
+      password: lease.password,
+      ssl,
+      max: 3,
+      idleTimeoutMillis: 3e4,
+      connectionTimeoutMillis: 1e4
+    });
+  };
+  const createDrizzle = (pool, s) => {
+    return drizzlePgMod.drizzle(pool, { schema: s });
+  };
+  return createSqlClientWithDeps(
+    {
+      fetchLease,
+      createPool,
+      createDrizzle,
+      schema
+    },
+    options
+  );
+}
+var LEASE_ENDPOINT, LEASE_RENEW_ENDPOINT;
+var init_sql_client = __esm({
+  "src/db/sql/sql-client.ts"() {
+    init_db_errors();
+    init_lease();
+    LEASE_ENDPOINT = "/api/sdk/v1/db/lease";
+    LEASE_RENEW_ENDPOINT = "/api/sdk/v1/db/lease/renew";
+  }
+});
+
 // src/auth.ts
 init_errors();
 
@@ -753,35 +1146,8 @@ function createSupportNamespace(config) {
   };
 }
 
-// src/db-errors.ts
-init_errors();
-var RETRYABLE_CODES2 = /* @__PURE__ */ new Set([
-  "db_unavailable",
-  "db_conflict",
-  "db_timeout"
-]);
-var NeetruDbError = class _NeetruDbError extends exports.NeetruError {
-  /** Código de erro fechado — específico de DB. */
-  code;
-  /**
-   * `true` para erros transientes que o produto pode tentar novamente.
-   * São retryable: `db_unavailable`, `db_conflict`, `db_timeout`.
-   */
-  retryable;
-  /**
-   * ID opaco do banco lógico — só para correlação com logs do Core.
-   * Nunca deve ser exibido ao usuário final.
-   */
-  dbId;
-  constructor(code, message, dbId) {
-    super(code, message);
-    this.name = "NeetruDbError";
-    this.code = code;
-    this.retryable = RETRYABLE_CODES2.has(code);
-    this.dbId = dbId;
-    Object.setPrototypeOf(this, _NeetruDbError.prototype);
-  }
-};
+// src/db/client-db.ts
+init_db_errors();
 
 // src/db/offline/query-engine.ts
 function typeRank(v) {
@@ -2828,13 +3194,14 @@ var TabCoordinator = class {
 };
 
 // src/db/collection-ref.ts
+init_db_errors();
 function isIndexedDBUnavailable() {
   return typeof indexedDB === "undefined" || typeof window === "undefined";
 }
 var COLL_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
 function assertValidCollection(name) {
   if (!COLL_RE.test(name)) {
-    throw new NeetruDbError(
+    throw new exports.NeetruDbError(
       "db_invalid_query",
       `Nome de cole\xE7\xE3o inv\xE1lido: "${name}". Deve seguir o padr\xE3o ${COLL_RE}.`
     );
@@ -2842,7 +3209,7 @@ function assertValidCollection(name) {
 }
 function assertValidId(id, label = "id") {
   if (!id || typeof id !== "string" || id.trim() === "") {
-    throw new NeetruDbError(
+    throw new exports.NeetruDbError(
       "db_invalid_query",
       `${label} \xE9 obrigat\xF3rio e deve ser uma string n\xE3o-vazia.`
     );
@@ -3413,307 +3780,6 @@ async function createOfflineDocumentsNamespace(opts) {
   });
 }
 
-// src/db/sql/lease.ts
-var RENEWAL_THRESHOLD = 0.8;
-var MIN_RENEWAL_DELAY_MS = 3e4;
-var SqlLeaseManager = class {
-  _lease;
-  _pool;
-  _orm;
-  _renewalTimer = null;
-  _closed = false;
-  _deps;
-  constructor(lease, pool, orm, deps) {
-    this._lease = lease;
-    this._pool = pool;
-    this._orm = orm;
-    this._deps = {
-      ...deps,
-      now: deps.now ?? (() => Date.now())
-    };
-    this._scheduleRenewal();
-  }
-  // ─── Superfície pública (NeetruSqlClient) ──────────────────────────────────
-  get orm() {
-    this._assertOpen();
-    return this._orm;
-  }
-  async transaction(fn, opts) {
-    this._assertOpen();
-    try {
-      if (opts?.isolationLevel) {
-        return await this._orm.transaction(fn, {
-          isolationLevel: opts.isolationLevel
-        });
-      }
-      return await this._orm.transaction(fn);
-    } catch (err) {
-      throw mapPoolError(err);
-    }
-  }
-  async close() {
-    if (this._closed) return;
-    this._closed = true;
-    this._cancelRenewal();
-    await this._pool.end().catch(() => {
-    });
-  }
-  // ─── Renovação proativa ────────────────────────────────────────────────────
-  /**
-   * Calcula o delay de renovação: momento de ~80% do TTL restante.
-   *
-   * Fórmula: `renewAt = issuedAt + TTL * RENEWAL_THRESHOLD`
-   *   = `expiresAt - TTL * (1 - RENEWAL_THRESHOLD)`
-   *
-   * Se o lease já está além do ponto de renovação (ou TTL não calculável),
-   * usa `MIN_RENEWAL_DELAY_MS` como fallback seguro.
-   */
-  _calcRenewalDelayMs() {
-    const expiresAtMs = Date.parse(this._lease.expiresAt);
-    if (!Number.isFinite(expiresAtMs)) return MIN_RENEWAL_DELAY_MS;
-    const now = this._deps.now();
-    const remainingMs = expiresAtMs - now;
-    if (remainingMs <= 0) return MIN_RENEWAL_DELAY_MS;
-    const renewInMs = remainingMs * (1 - RENEWAL_THRESHOLD);
-    return Math.max(MIN_RENEWAL_DELAY_MS, Math.round(renewInMs));
-  }
-  _scheduleRenewal() {
-    if (this._closed) return;
-    const delayMs = this._calcRenewalDelayMs();
-    this._renewalTimer = setTimeout(() => {
-      void this._doRenew();
-    }, delayMs);
-  }
-  _cancelRenewal() {
-    if (this._renewalTimer !== null) {
-      clearTimeout(this._renewalTimer);
-      this._renewalTimer = null;
-    }
-  }
-  async _doRenew() {
-    if (this._closed) return;
-    try {
-      const renewOpts = {
-        leaseId: this._lease.leaseId
-      };
-      if (this._deps.database !== void 0) {
-        renewOpts.database = this._deps.database;
-      }
-      const newLease = await this._deps.fetchLease(renewOpts);
-      await this._swapPool(newLease);
-    } catch (err) {
-      this._renewalTimer = setTimeout(() => {
-        void this._doRenew();
-      }, MIN_RENEWAL_DELAY_MS);
-      if (process.env["NODE_ENV"] !== "production") {
-        console.warn("[SqlLeaseManager] Lease renewal failed, will retry:", err);
-      }
-      return;
-    }
-    this._scheduleRenewal();
-  }
-  /**
-   * Hot-swap do pool: cria pool novo, atualiza ponteiros, drena pool antigo.
-   *
-   * Exposto como método protegido para testes.
-   */
-  async _swapPool(newLease) {
-    const credRotated = newLease.credentialVersion !== this._lease.credentialVersion;
-    if (!credRotated && newLease.leaseId === this._lease.leaseId) {
-      this._lease = newLease;
-      return;
-    }
-    const newPool = this._deps.createPool(newLease);
-    const newOrm = this._deps.createDrizzle(newPool, this._deps.schema);
-    const oldPool = this._pool;
-    this._lease = newLease;
-    this._pool = newPool;
-    this._orm = newOrm;
-    void oldPool.end().catch(() => {
-    });
-  }
-  // ─── Helpers ───────────────────────────────────────────────────────────────
-  _assertOpen() {
-    if (this._closed) {
-      throw new NeetruDbError(
-        "db_unavailable",
-        "SqlLeaseManager foi fechado \u2014 chame close() apenas no shutdown."
-      );
-    }
-  }
-};
-function mapPoolError(err) {
-  if (err instanceof NeetruDbError) return err;
-  const message = err instanceof Error ? err.message : String(err);
-  const code = err instanceof Error ? err.code : void 0;
-  if (typeof code === "string" && (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT")) {
-    return new NeetruDbError(
-      "db_unavailable",
-      `Pool connection failed (${code}): ${message}`
-    );
-  }
-  if (message.includes("statement timeout") || message.includes("lock timeout")) {
-    return new NeetruDbError("db_timeout", `Query timeout: ${message}`);
-  }
-  if (message.includes("40001") || message.includes("40P01") || message.includes("deadlock")) {
-    return new NeetruDbError("db_conflict", `Transaction conflict: ${message}`);
-  }
-  if (message.includes("42501") || message.toLowerCase().includes("permission denied")) {
-    return new NeetruDbError("db_permission_denied", `Permission denied: ${message}`);
-  }
-  return new NeetruDbError("db_unavailable", `Database error: ${message}`);
-}
-
-// src/db/sql/sql-client.ts
-var LEASE_ENDPOINT = "/api/sdk/v1/db/lease";
-var LEASE_RENEW_ENDPOINT = "/api/sdk/v1/db/lease/renew";
-function mapEnvToCore(sdkEnv) {
-  if (sdkEnv === "workspace") return "staging";
-  if (sdkEnv === "prod") return "production";
-  return "dev";
-}
-function createHttpLeaseFetcher(config) {
-  return async (opts) => {
-    const { httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_http(), http_exports));
-    const isRenewal = Boolean(opts?.leaseId);
-    const path = isRenewal ? LEASE_RENEW_ENDPOINT : LEASE_ENDPOINT;
-    let body;
-    if (isRenewal) {
-      body = { leaseId: opts.leaseId };
-    } else {
-      body = {
-        productId: config.productId ?? "",
-        environment: mapEnvToCore(config.env ?? "prod")
-      };
-      if (opts?.database !== void 0) {
-        body["database"] = opts.database;
-      }
-    }
-    let raw;
-    try {
-      raw = await httpRequest2(config, {
-        method: "POST",
-        path,
-        body,
-        requireAuth: true,
-        // Lease fetch é idempotente do ponto de vista de segurança — retries OK.
-        retries: 2
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      throw new NeetruDbError(
-        "db_unavailable",
-        `Falha ao ${isRenewal ? "renovar" : "obter"} lease SQL: ${msg}`
-      );
-    }
-    return parseLease(raw);
-  };
-}
-function parseLease(raw) {
-  if (!raw || typeof raw !== "object") {
-    throw new NeetruDbError("db_unavailable", "Resposta de lease inv\xE1lida (n\xE3o \xE9 objeto).");
-  }
-  const envelope = raw;
-  const leaseObj = envelope["lease"];
-  if (!leaseObj || typeof leaseObj !== "object") {
-    throw new NeetruDbError(
-      "db_unavailable",
-      'Resposta de lease inv\xE1lida: campo "lease" ausente ou n\xE3o \xE9 objeto. O Core retorna { kind, lease: { leaseId, host, ... } }.'
-    );
-  }
-  const r = leaseObj;
-  function req(field, type) {
-    if (typeof r[field] !== type) {
-      throw new NeetruDbError(
-        "db_unavailable",
-        `Campo obrigat\xF3rio "${field}" ausente ou tipo inv\xE1lido na resposta de lease.`
-      );
-    }
-    return r[field];
-  }
-  return {
-    leaseId: req("leaseId", "string"),
-    host: req("host", "string"),
-    port: typeof r["port"] === "number" ? r["port"] : 5433,
-    dbName: req("dbName", "string"),
-    user: req("user", "string"),
-    password: req("password", "string"),
-    sslca: typeof r["sslca"] === "string" ? r["sslca"] : null,
-    clientCert: typeof r["clientCert"] === "string" ? r["clientCert"] : null,
-    clientKey: typeof r["clientKey"] === "string" ? r["clientKey"] : null,
-    credentialVersion: typeof r["credentialVersion"] === "number" ? r["credentialVersion"] : 1,
-    expiresAt: req("expiresAt", "string")
-  };
-}
-async function createSqlClientWithDeps(deps, options) {
-  const depsWithDb = options?.database !== void 0 ? { ...deps, database: options.database } : deps;
-  let lease;
-  try {
-    if (options?.database !== void 0) {
-      lease = await depsWithDb.fetchLease({ database: options.database });
-    } else {
-      lease = await depsWithDb.fetchLease();
-    }
-  } catch (err) {
-    if (err instanceof NeetruDbError) throw err;
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new NeetruDbError("db_unavailable", `Falha ao obter lease inicial: ${msg}`);
-  }
-  let pool;
-  try {
-    pool = depsWithDb.createPool(lease);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new NeetruDbError("db_unavailable", `Falha ao abrir pool: ${msg}`);
-  }
-  let orm;
-  try {
-    orm = depsWithDb.createDrizzle(pool, depsWithDb.schema);
-  } catch (err) {
-    await pool.end().catch(() => {
-    });
-    const msg = err instanceof Error ? err.message : String(err);
-    throw new NeetruDbError("db_unavailable", `Falha ao criar handle Drizzle: ${msg}`);
-  }
-  return new SqlLeaseManager(lease, pool, orm, depsWithDb);
-}
-async function createSqlClientFromConfig(config, schema, options) {
-  const fetchLease = createHttpLeaseFetcher(config);
-  const createPool = (lease) => {
-    const { Pool } = __require("pg");
-    const ssl = lease.sslca ? {
-      ca: lease.sslca,
-      cert: lease.clientCert ?? void 0,
-      key: lease.clientKey ?? void 0,
-      rejectUnauthorized: true
-    } : false;
-    return new Pool({
-      host: lease.host,
-      port: lease.port,
-      database: lease.dbName,
-      user: lease.user,
-      password: lease.password,
-      ssl,
-      max: 3,
-      idleTimeoutMillis: 3e4,
-      connectionTimeoutMillis: 1e4
-    });
-  };
-  const createDrizzle = (pool, s) => {
-    const { drizzle } = __require("drizzle-orm/node-postgres");
-    return drizzle(pool, { schema: s });
-  };
-  return createSqlClientWithDeps(
-    {
-      fetchLease,
-      createPool,
-      createDrizzle,
-      schema
-    },
-    options
-  );
-}
-
 // src/db/realtime/realtime-client.ts
 var WS_OPEN = 1;
 var WS_CLOSED = 3;
@@ -4160,7 +4226,7 @@ function createRestSyncTransport(config) {
   return {
     async pushMutations(mutations) {
       if (!config) {
-        throw new NeetruDbError(
+        throw new exports.NeetruDbError(
           "db_unavailable",
           "[RestSyncTransport] config n\xE3o dispon\xEDvel \u2014 n\xE3o \xE9 poss\xEDvel enviar ao Core. Inicialize o transporte via createNeetruDb."
         );
@@ -4217,7 +4283,7 @@ function createRestSyncTransport(config) {
           });
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
-          throw new NeetruDbError("db_unavailable", `pushMutations falhou: ${msg}`);
+          throw new exports.NeetruDbError("db_unavailable", `pushMutations falhou: ${msg}`);
         }
       }
       return { results };
@@ -4331,12 +4397,13 @@ function createNeetruDb(config, dbOpts = {}) {
     },
     async sql(schema, options) {
       if (config.env === "dev") {
-        throw new NeetruDbError(
+        throw new exports.NeetruDbError(
           "db_unavailable",
           "[SDK] db.sql() n\xE3o dispon\xEDvel em NEETRU_ENV=dev. Use `neetru dev` para subir o container Postgres local."
         );
       }
-      return createSqlClientFromConfig(config, schema, options);
+      const sqlClientMod = await Promise.resolve().then(() => (init_sql_client(), sql_client_exports));
+      return sqlClientMod.createSqlClientFromConfig(config, schema, options);
     },
     get syncState() {
       return _docsResolved?.syncState ?? {
@@ -4941,6 +5008,7 @@ var MockNotifications = class {
 };
 
 // src/mocks.ts
+init_db_errors();
 var DEV_FIXTURE_USER = Object.freeze({
   uid: "dev-fixture-uid-0001",
   email: "dev@neetru.local",
@@ -5370,35 +5438,59 @@ var MockDb = class {
     return ref;
   }
   /**
-   * Implementa SQL in-memory via `pg-mem` + `drizzle-orm/node-postgres`.
+   * Implementa SQL in-memory para testes — preferência: `@electric-sql/pglite`
+   * + `drizzle-orm/pglite`; fallback: `pg-mem` + `drizzle-orm/node-postgres`
+   * com strip interceptor.
    *
-   * bug_a7f2ae25fda54129b52b6dd55aaa6050 (HIGH 26/05): antes lançava
-   * `db_unavailable` sempre, bloqueando vitest server-side dos consumers
-   * que refatoraram pra `client.db.sql()`. Agora carrega `pg-mem` lazy +
-   * cria `NodePgDatabase` Drizzle apontando pra DB in-memory.
+   * bug_6bae8674461f4600809e2f9de13c6043 (HIGH 26/05): fix anterior (2.3.3)
+   * teve efeito INVERSO. Injetar `pool.types.getTypeParser` fez drizzle-orm
+   * passar `query.types.getTypeParser` pro pg-mem, que tem guard interno
+   * `if (query.types?.getTypeParser) throw NotSupported`. Ou seja: presença
+   * de getTypeParser é o gatilho do erro — não ausência.
    *
-   * Requer `pg-mem`, `drizzle-orm` e `pg` como devDependencies do consumer
-   * (instale com `npm install -D pg-mem drizzle-orm pg`). Se ausentes, joga
-   * `db_unavailable` com mensagem clara.
+   * Solução A (pglite, preferida): `@electric-sql/pglite` é WASM-Postgres
+   * nativo — sem adapter pg-mem, sem esse conflito de tipos.
+   * Solução B (fallback pg-mem): strip interceptor no pool.query que deleta
+   * `types.getTypeParser` do objeto de query ANTES do pg-mem ver. Compat com
+   * consumers que só têm pg-mem nas devDeps.
    *
-   * Use `options.initSql` pra criar tabelas no test setup — sem isso o orm
-   * funciona mas qualquer SELECT/INSERT em tabela inexistente vai falhar.
+   * Use `options.initSql` pra rodar DDL no setup (CREATE TABLE etc).
    */
   async sql(schema, options) {
+    const ddls = options?.initSql ? Array.isArray(options.initSql) ? options.initSql : [options.initSql] : [];
+    try {
+      const pglitePkg = await import('@electric-sql/pglite');
+      const drizzlePglitePkg = await import('drizzle-orm/pglite');
+      const pglite = await pglitePkg.PGlite.create();
+      for (const ddl of ddls) {
+        await pglite.query(ddl);
+      }
+      const pgliteOrm = drizzlePglitePkg.drizzle(pglite, { schema });
+      const ormAsNode = pgliteOrm;
+      return {
+        orm: ormAsNode,
+        async transaction(fn, _opts) {
+          return await pgliteOrm.transaction(fn);
+        },
+        async close() {
+          if (!pglite.closed) await pglite.close();
+        }
+      };
+    } catch (_pgliteErr) {
+    }
     let pgMemMod;
     let drizzlePg;
     try {
       pgMemMod = await import('pg-mem');
       drizzlePg = await import('drizzle-orm/node-postgres');
     } catch {
-      throw new NeetruDbError(
+      throw new exports.NeetruDbError(
         "db_unavailable",
-        "[MockDb] sql() requer pg-mem + drizzle-orm + pg como devDependencies do consumer. Rode: npm install -D pg-mem drizzle-orm pg."
+        "[MockDb] sql() requer @electric-sql/pglite OU pg-mem + drizzle-orm + pg como devDependencies. Preferido: npm install -D @electric-sql/pglite drizzle-orm. Alternativo: npm install -D pg-mem drizzle-orm pg."
       );
     }
     const memDb = pgMemMod.newDb({ noAstCoverageCheck: true });
-    if (options?.initSql) {
-      const ddls = Array.isArray(options.initSql) ? options.initSql : [options.initSql];
+    if (ddls.length > 0) {
       for (const ddl of ddls) {
         memDb.public.none(ddl);
       }
@@ -5406,12 +5498,17 @@ var MockDb = class {
     const adapters = memDb.adapters.createPg();
     const PoolCtor = adapters.Pool;
     const pool = new PoolCtor();
-    const existingTypes = pool.types;
-    if (!existingTypes || typeof existingTypes.getTypeParser !== "function") {
-      pool.types = {
-        getTypeParser: () => (val) => val
-      };
-    }
+    const origQuery = pool.query.bind(pool);
+    pool.query = (q, ...rest) => {
+      if (q !== null && typeof q === "object") {
+        const queryObj = q;
+        const types = queryObj["types"];
+        if (types !== null && typeof types === "object" && "getTypeParser" in types) {
+          delete types["getTypeParser"];
+        }
+      }
+      return origQuery(q, ...rest);
+    };
     const orm = drizzlePg.drizzle(pool, { schema });
     return {
       orm,
@@ -5701,6 +5798,7 @@ function createNeetruClient(config = {}) {
 
 // src/index.ts
 init_errors();
+init_db_errors();
 var VERSION = "2.0.0";
 function initNeetru(config) {
   const { apiUrl: _apiUrl, baseUrl, ...rest } = config;
@@ -5717,7 +5815,6 @@ exports.MockNotifications = MockNotifications;
 exports.MockSupport = MockSupport;
 exports.MockUsage = MockUsage;
 exports.MockWebhooks = MockWebhooks;
-exports.NeetruDbError = NeetruDbError;
 exports.VERSION = VERSION;
 exports.createCheckoutNamespace = createCheckoutNamespace;
 exports.createNeetruClient = createNeetruClient;