@neetru/sdk 3.5.0 → 3.7.0

package/dist/firestore-compat.d.ts

@@ -1,4 +1,4 @@
-import { Y as NeetruDb, E as DbCollectionRef, P as FieldSentinel, K as DbQuery } from './types-BPATkXYu.js';
+import { Y as NeetruDb, E as DbCollectionRef, P as FieldSentinel, K as DbQuery } from './types-Dx0IrOSF.js';
 import 'drizzle-orm/node-postgres';
 import './errors.js';
 

package/dist/firestore-compat.mjs

@@ -1,143 +1,122 @@
 // src/db/field-value.ts
-function serverTimestamp() {
+function g() {
   return { __neetru__: "serverTimestamp" };
 }
-function increment(n) {
-  if (typeof n !== "number" || !Number.isFinite(n)) {
+function b(e) {
+  if (typeof e != "number" || !Number.isFinite(e))
     throw new TypeError(
-      `increment(n): n deve ser um n\xFAmero finito (recebido: ${String(n)}).`
+      `increment(n): n deve ser um n\xFAmero finito (recebido: ${String(e)}).`
     );
-  }
-  return { __neetru__: "increment", operand: n };
+  return { __neetru__: "increment", operand: e };
 }
 
 // src/firestore-compat.ts
-function isClientWrapper(v) {
-  return typeof v === "object" && v !== null && "db" in v && typeof v.db === "object" && v.db?.collection !== void 0;
+function h(e) {
+  return typeof e == "object" && e !== null && "db" in e && typeof e.db == "object" && e.db?.collection !== void 0;
 }
-function resolveDb(handle) {
-  if (handle.__neetruFirestore) return handle.db;
-  if (isClientWrapper(handle)) return handle.db;
-  return handle;
+function u(e) {
+  return e.__neetruFirestore || h(e) ? e.db : e;
 }
-function getFirestore(handle) {
-  return { __neetruFirestore: true, db: resolveDb(handle) };
+function P(e) {
+  return { __neetruFirestore: true, db: u(e) };
 }
-function collection(db, name) {
-  const resolved = resolveDb(db);
+function E(e, n) {
+  let t = u(e);
   return {
     type: "collection",
     __kind: "collection",
-    id: name,
-    path: name,
-    db: resolved,
-    ref: resolved.collection(name)
+    id: n,
+    path: n,
+    db: t,
+    ref: t.collection(n)
   };
 }
-function doc(dbOrCollection, ...path) {
-  if (typeof dbOrCollection === "object" && dbOrCollection !== null && dbOrCollection.__kind === "collection") {
-    const col = dbOrCollection;
-    const id = path[0] ?? generateId();
-    return makeDocRef(col.db, col.id, id);
-  }
-  const resolved = resolveDb(dbOrCollection);
-  if (path.length >= 2) {
-    return makeDocRef(resolved, path[0], path.slice(1).join("/"));
+function A(e, ...n) {
+  if (typeof e == "object" && e !== null && e.__kind === "collection") {
+    let r = e, i = n[0] ?? m();
+    return d(r.db, r.id, i);
   }
-  if (path[0]?.includes("/")) {
-    const parts = path[0].split("/");
-    return makeDocRef(resolved, parts[0], parts.slice(1).join("/") || generateId());
+  let t = u(e);
+  if (n.length >= 2)
+    return d(t, n[0], n.slice(1).join("/"));
+  if (n[0]?.includes("/")) {
+    let r = n[0].split("/");
+    return d(t, r[0], r.slice(1).join("/") || m());
   }
-  return makeDocRef(resolved, path[0] ?? "", generateId());
+  return d(t, n[0] ?? "", m());
 }
-function makeDocRef(db, collectionName, id) {
+function d(e, n, t) {
   return {
     type: "document",
     __kind: "document",
-    id,
-    collection: collectionName,
-    path: `${collectionName}/${id}`,
-    db
+    id: t,
+    collection: n,
+    path: `${n}/${t}`,
+    db: e
   };
 }
-function generateId() {
-  const CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  const cryptoObj = globalThis.crypto;
-  if (!cryptoObj?.getRandomValues) {
+function m() {
+  let e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", n = globalThis.crypto;
+  if (!n?.getRandomValues)
     throw new Error(
       "[Neetru SDK / firestore-compat] WebCrypto indispon\xEDvel: generateId() exige globalThis.crypto.getRandomValues (Node \u226520 ou ambiente browser)."
     );
-  }
-  let out = "";
-  while (out.length < 20) {
-    const buf = new Uint8Array(20 - out.length);
-    cryptoObj.getRandomValues(buf);
-    for (const byte of buf) {
-      if (byte < 248) {
-        out += CHARS[byte % 62];
-        if (out.length === 20) break;
-      }
-    }
-  }
-  return out;
-}
-function query(source, ...constraints) {
-  const base = source.__kind === "query" ? source : {
+  let t = "";
+  for (; t.length < 20; ) {
+    let r = new Uint8Array(20 - t.length);
+    n.getRandomValues(r);
+    for (let i of r)
+      if (i < 248 && (t += e[i % 62], t.length === 20))
+        break;
+  }
+  return t;
+}
+function B(e, ...n) {
+  let t = e.__kind === "query" ? e : {
     type: "query",
     __kind: "query",
-    path: source.path,
-    collection: source.id,
-    db: source.db,
-    ref: source.ref,
+    path: e.path,
+    collection: e.id,
+    db: e.db,
+    ref: e.ref,
     constraints: []
   };
-  return { ...base, constraints: [...base.constraints, ...constraints] };
-}
-function where(field, op, value) {
-  return { __constraint: "where", field, op, value };
-}
-function orderBy(field, direction = "asc") {
-  return { __constraint: "orderBy", field, direction };
-}
-function limit(value) {
-  return { __constraint: "limit", value };
-}
-function toDbQuery(constraints) {
-  const whereFilters = [];
-  let orderByClause;
-  let limitValue;
-  for (const c of constraints) {
-    if (c.__constraint === "where") {
-      const w = c;
-      whereFilters.push({ field: w.field, op: normalizeOp(w.op), value: w.value });
-    } else if (c.__constraint === "orderBy") {
-      const o = c;
-      orderByClause = { field: o.field, direction: o.direction };
-    } else if (c.__constraint === "limit") {
-      limitValue = c.value;
-    }
-  }
-  const out = {};
-  if (whereFilters.length > 0) out.where = whereFilters;
-  if (orderByClause) out.orderBy = orderByClause;
-  if (limitValue !== void 0) out.limit = limitValue;
-  return out;
-}
-function normalizeOp(op) {
-  return op;
-}
-function stripId(raw) {
-  if (raw && typeof raw === "object" && "id" in raw) {
-    const { id: _omit, ...rest } = raw;
-    return rest;
-  }
-  return raw;
-}
-var DocumentSnapshot = class {
-  constructor(id, _data, ref) {
-    this.id = id;
-    this._data = _data;
-    this.ref = ref;
+  return { ...t, constraints: [...t.constraints, ...n] };
+}
+function L(e, n, t) {
+  return { __constraint: "where", field: e, op: n, value: t };
+}
+function W(e, n = "asc") {
+  return { __constraint: "orderBy", field: e, direction: n };
+}
+function I(e) {
+  return { __constraint: "limit", value: e };
+}
+function w(e) {
+  let n = [], t, r;
+  for (let s of e)
+    if (s.__constraint === "where") {
+      let o = s;
+      n.push({ field: o.field, op: o.op, value: o.value });
+    } else if (s.__constraint === "orderBy") {
+      let o = s;
+      t = { field: o.field, direction: o.direction };
+    } else s.__constraint === "limit" && (r = s.value);
+  let i = {};
+  return n.length > 0 && (i.where = n), t && (i.orderBy = t), r !== void 0 && (i.limit = r), i;
+}
+function y(e) {
+  if (e && typeof e == "object" && "id" in e) {
+    let { id: n, ...t } = e;
+    return t;
+  }
+  return e;
+}
+var l = class {
+  constructor(n, t, r) {
+    this.id = n;
+    this._data = t;
+    this.ref = r;
   }
   id;
   _data;
@@ -149,200 +128,167 @@ var DocumentSnapshot = class {
     return this._data ?? void 0;
   }
   /** Compat: `snap.get('field')` lê um campo top-level. */
-  get(field) {
-    return this._data ? this._data[field] : void 0;
+  get(n) {
+    return this._data ? this._data[n] : void 0;
   }
-};
-var QuerySnapshot = class {
+}, p = class {
   docs;
   empty;
   size;
-  constructor(rows, db, collectionName) {
-    this.docs = rows.map(({ id, data }) => {
-      const stripped = stripId(data);
-      const ref = db && collectionName ? makeDocRef(db, collectionName, id) : void 0;
+  constructor(n, t, r) {
+    this.docs = n.map(({ id: i, data: s }) => {
+      let o = y(s), a = t && r ? d(t, r, i) : void 0;
       return {
-        id,
-        data: () => stripped,
+        id: i,
+        data: () => o,
         exists: () => true,
-        get: (field) => stripped?.[field],
+        get: (c) => o?.[c],
         // ref sempre presente quando db+collection conhecidos (caso comum).
-        ref
+        ref: a
       };
-    });
-    this.empty = this.docs.length === 0;
-    this.size = this.docs.length;
+    }), this.empty = this.docs.length === 0, this.size = this.docs.length;
   }
-  forEach(cb) {
-    this.docs.forEach(cb);
+  forEach(n) {
+    this.docs.forEach(n);
   }
 };
-function firstDocData(result) {
-  const first = result?.docs[0];
-  return { data: first ? first.data : null, id: first?.id ?? null };
-}
-async function getDoc(ref) {
-  const result = await ref.db.collection(ref.collection).get(ref.id);
-  const { data } = firstDocData(result);
-  return new DocumentSnapshot(
-    ref.id,
-    data ? stripId({ id: ref.id, ...data }) : null,
-    ref
+function D(e) {
+  let n = e?.docs[0];
+  return { data: n ? n.data : null, id: n?.id ?? null };
+}
+async function x(e) {
+  let n = await e.db.collection(e.collection).get(e.id), { data: t } = D(n);
+  return new l(
+    e.id,
+    t ? y({ id: e.id, ...t }) : null,
+    e
   );
 }
-function listResultToRows(result) {
-  return result.docs.map((d) => ({ id: d.id, data: { ...d.data } }));
+function k(e) {
+  return e.docs.map((n) => ({ id: n.id, data: { ...n.data } }));
 }
-async function getDocs(source) {
-  const dbQuery = source.__kind === "query" ? toDbQuery(source.constraints) : void 0;
-  const collectionName = source.__kind === "query" ? source.collection : source.id;
-  const result = await source.db.collection(collectionName).list(dbQuery);
-  return new QuerySnapshot(listResultToRows(result), source.db, collectionName);
+async function U(e) {
+  let n = e.__kind === "query" ? w(e.constraints) : void 0, t = e.__kind === "query" ? e.collection : e.id, r = await e.db.collection(t).list(n);
+  return new p(k(r), e.db, t);
 }
-async function setDoc(ref, data, options = {}) {
-  const col = ref.db.collection(ref.collection);
-  const payload = data;
-  if (options.merge || options.mergeFields && options.mergeFields.length > 0) {
-    await col.update(ref.id, payload, { upsert: true });
-  } else {
-    await col.set(ref.id, payload);
-  }
+async function j(e, n, t = {}) {
+  let r = e.db.collection(e.collection), i = n;
+  t.merge || t.mergeFields && t.mergeFields.length > 0 ? await r.update(e.id, i, { upsert: true }) : await r.set(e.id, i);
 }
-async function addDoc(source, data) {
-  const result = await source.db.collection(source.id).add(data);
-  return makeDocRef(source.db, source.id, result.id);
+async function q(e, n) {
+  let t = await e.db.collection(e.id).add(n);
+  return d(e.db, e.id, t.id);
 }
-async function updateDoc(ref, data) {
-  await ref.db.collection(ref.collection).update(ref.id, data);
+async function M(e, n) {
+  await e.db.collection(e.collection).update(e.id, n);
 }
-async function deleteDoc(ref) {
-  await ref.db.collection(ref.collection).remove(ref.id);
+async function $(e) {
+  await e.db.collection(e.collection).remove(e.id);
 }
-var WriteBatch = class {
-  constructor(db) {
-    this.db = db;
+var f = class {
+  constructor(n) {
+    this.db = n;
   }
   db;
   ops = [];
-  set(ref, data, options) {
-    const merge = !!(options?.merge || options?.mergeFields && options.mergeFields.length > 0);
-    this.ops.push({
-      collection: ref.collection,
-      op: merge ? { kind: "update", id: ref.id, data, upsert: true } : { kind: "set", id: ref.id, data }
-    });
-    return this;
-  }
-  update(ref, data) {
-    this.ops.push({
-      collection: ref.collection,
-      op: { kind: "update", id: ref.id, data }
-    });
-    return this;
-  }
-  delete(ref) {
-    this.ops.push({ collection: ref.collection, op: { kind: "remove", id: ref.id } });
-    return this;
+  set(n, t, r) {
+    let i = !!(r?.merge || r?.mergeFields && r.mergeFields.length > 0);
+    return this.ops.push({
+      collection: n.collection,
+      op: i ? { kind: "update", id: n.id, data: t, upsert: true } : { kind: "set", id: n.id, data: t }
+    }), this;
+  }
+  update(n, t) {
+    return this.ops.push({
+      collection: n.collection,
+      op: { kind: "update", id: n.id, data: t }
+    }), this;
+  }
+  delete(n) {
+    return this.ops.push({ collection: n.collection, op: { kind: "remove", id: n.id } }), this;
   }
   async commit() {
-    const byCol = /* @__PURE__ */ new Map();
-    for (const { collection: name, op } of this.ops) {
-      const list = byCol.get(name) ?? [];
-      list.push(op);
-      byCol.set(name, list);
-    }
-    for (const [name, ops] of byCol.entries()) {
-      await this.db.collection(name).batch(ops);
+    let n = /* @__PURE__ */ new Map();
+    for (let { collection: t, op: r } of this.ops) {
+      let i = n.get(t) ?? [];
+      i.push(r), n.set(t, i);
     }
+    for (let [t, r] of n.entries())
+      await this.db.collection(t).batch(r);
     this.ops = [];
   }
 };
-function writeBatch(db) {
-  return new WriteBatch(resolveDb(db));
-}
-var _runTransactionWarnEmitted = false;
-async function runTransaction(db, updateFunction) {
-  if (!_runTransactionWarnEmitted) {
-    _runTransactionWarnEmitted = true;
-    console.warn(
-      "[Neetru SDK / firestore-compat] runTransaction(): esta emula\xE7\xE3o N\xC3O oferece isolamento server-side. Reads e writes s\xE3o executados em rounds separados; um write concorrente entre o get() e o commit() resultar\xE1 em lost-update silencioso. Para atomicidade real, use Server Actions no Core ou sentinels increment()/arrayUnion(). Veja a doc em src/firestore-compat.ts \xA7 runTransaction."
-    );
-  }
-  const resolved = resolveDb(db);
-  const batch = new WriteBatch(resolved);
-  const tx = {
-    async get(ref) {
-      return getDoc(ref);
+function V(e) {
+  return new f(u(e));
+}
+var R = false;
+async function z(e, n) {
+  R || (R = true, console.warn(
+    "[Neetru SDK / firestore-compat] runTransaction(): esta emula\xE7\xE3o N\xC3O oferece isolamento server-side. Reads e writes s\xE3o executados em rounds separados; um write concorrente entre o get() e o commit() resultar\xE1 em lost-update silencioso. Para atomicidade real, use Server Actions no Core ou sentinels increment()/arrayUnion(). Veja a doc em src/firestore-compat.ts \xA7 runTransaction."
+  ));
+  let t = u(e), r = new f(t), i = {
+    async get(o) {
+      return x(o);
     },
-    set(ref, data, options) {
-      batch.set(ref, data, options);
-      return tx;
+    set(o, a, c) {
+      return r.set(o, a, c), i;
     },
-    update(ref, data) {
-      batch.update(ref, data);
-      return tx;
+    update(o, a) {
+      return r.update(o, a), i;
     },
-    delete(ref) {
-      batch.delete(ref);
-      return tx;
+    delete(o) {
+      return r.delete(o), i;
     }
-  };
-  const result = await updateFunction(tx);
-  await batch.commit();
-  return result;
+  }, s = await n(i);
+  return await r.commit(), s;
 }
-function onSnapshot(source, onNext, onError) {
-  if (source.__kind === "document") {
-    const ref = source;
-    const docRef = ref.db.collection(ref.collection).doc(ref.id);
+function G(e, n, t) {
+  if (e.__kind === "document") {
+    let o = e, a = o.db.collection(o.collection).doc(o.id);
     try {
-      return docRef.onSnapshot((snap) => {
-        const data = snap?.docs[0]?.data;
-        onNext(
-          new DocumentSnapshot(
-            ref.id,
-            data ? stripId({ id: ref.id, ...data }) : null,
-            ref
+      return a.onSnapshot((c) => {
+        let T = c?.docs[0]?.data;
+        n(
+          new l(
+            o.id,
+            T ? y({ id: o.id, ...T }) : null,
+            o
           )
         );
       });
-    } catch (err) {
-      onError?.(err instanceof Error ? err : new Error(String(err)));
-      return () => {
+    } catch (c) {
+      return t?.(c instanceof Error ? c : new Error(String(c))), () => {
       };
     }
   }
-  const collectionName = source.__kind === "query" ? source.collection : source.id;
-  const dbQuery = source.__kind === "query" ? toDbQuery(source.constraints) : void 0;
-  const col = source.db.collection(collectionName);
+  let r = e.__kind === "query" ? e.collection : e.id, i = e.__kind === "query" ? w(e.constraints) : void 0, s = e.db.collection(r);
   try {
-    return col.onSnapshot(dbQuery, (snap) => {
-      onNext(
-        new QuerySnapshot(listResultToRows(snap), source.db, collectionName)
+    return s.onSnapshot(i, (o) => {
+      n(
+        new p(k(o), e.db, r)
       );
     });
-  } catch (err) {
-    onError?.(err instanceof Error ? err : new Error(String(err)));
-    return () => {
+  } catch (o) {
+    return t?.(o instanceof Error ? o : new Error(String(o))), () => {
     };
   }
 }
-var Timestamp = class _Timestamp {
-  constructor(seconds, nanoseconds) {
-    this.seconds = seconds;
-    this.nanoseconds = nanoseconds;
+var _ = class e {
+  constructor(n, t) {
+    this.seconds = n;
+    this.nanoseconds = t;
   }
   seconds;
   nanoseconds;
   static now() {
-    return _Timestamp.fromMillis(Date.now());
+    return e.fromMillis(Date.now());
   }
-  static fromDate(date) {
-    return _Timestamp.fromMillis(date.getTime());
+  static fromDate(n) {
+    return e.fromMillis(n.getTime());
   }
-  static fromMillis(millis) {
-    const seconds = Math.floor(millis / 1e3);
-    const nanoseconds = (millis - seconds * 1e3) * 1e6;
-    return new _Timestamp(seconds, nanoseconds);
+  static fromMillis(n) {
+    let t = Math.floor(n / 1e3), r = (n - t * 1e3) * 1e6;
+    return new e(t, r);
   }
   toDate() {
     return new Date(this.toMillis());
@@ -350,8 +296,8 @@ var Timestamp = class _Timestamp {
   toMillis() {
     return this.seconds * 1e3 + Math.floor(this.nanoseconds / 1e6);
   }
-  isEqual(other) {
-    return this.seconds === other.seconds && this.nanoseconds === other.nanoseconds;
+  isEqual(n) {
+    return this.seconds === n.seconds && this.nanoseconds === n.nanoseconds;
   }
   valueOf() {
     return `${this.seconds.toString().padStart(12, "0")}.${this.nanoseconds.toString().padStart(9, "0")}`;
@@ -363,29 +309,27 @@ var Timestamp = class _Timestamp {
     return `Timestamp(seconds=${this.seconds}, nanoseconds=${this.nanoseconds})`;
   }
 };
-function serverTimestamp2() {
-  return serverTimestamp();
+function S() {
+  return g();
 }
-function increment2(n) {
-  return increment(n);
+function F(e) {
+  return b(e);
 }
-function arrayUnion(...elements) {
-  return { __neetru__: "arrayUnion", elements };
+function v(...e) {
+  return { __neetru__: "arrayUnion", elements: e };
 }
-function arrayRemove(...elements) {
-  return { __neetru__: "arrayRemove", elements };
+function C(...e) {
+  return { __neetru__: "arrayRemove", elements: e };
 }
-function deleteField() {
+function N() {
   return { __neetru__: "deleteField" };
 }
-var FieldValue = {
-  serverTimestamp: serverTimestamp2,
-  increment: increment2,
-  arrayUnion,
-  arrayRemove,
-  delete: deleteField
+var K = {
+  serverTimestamp: S,
+  increment: F,
+  arrayUnion: v,
+  arrayRemove: C,
+  delete: N
 };
 
-export { DocumentSnapshot, FieldValue, QuerySnapshot, Timestamp, WriteBatch, addDoc, arrayRemove, arrayUnion, collection, deleteDoc, deleteField, doc, getDoc, getDocs, getFirestore, increment2 as increment, limit, onSnapshot, orderBy, query, runTransaction, serverTimestamp2 as serverTimestamp, setDoc, toDbQuery, updateDoc, where, writeBatch };
-//# sourceMappingURL=firestore-compat.mjs.map
-//# sourceMappingURL=firestore-compat.mjs.map
+export { l as DocumentSnapshot, K as FieldValue, p as QuerySnapshot, _ as Timestamp, f as WriteBatch, q as addDoc, C as arrayRemove, v as arrayUnion, E as collection, $ as deleteDoc, N as deleteField, A as doc, x as getDoc, U as getDocs, P as getFirestore, F as increment, I as limit, G as onSnapshot, W as orderBy, B as query, z as runTransaction, S as serverTimestamp, j as setDoc, w as toDbQuery, M as updateDoc, L as where, V as writeBatch };