fire2mongo 1.0.0

package/dist/index.mjs

@@ -0,0 +1,518 @@
+// src/connection.ts
+import { MongoClient } from "mongodb";
+var _client = null;
+var _db = null;
+async function initMongoDB(config) {
+  if (_db) return _db;
+  _client = new MongoClient(config.uri);
+  await _client.connect();
+  _db = _client.db(config.dbName);
+  return _db;
+}
+function getDb() {
+  if (!_db) {
+    throw new Error(
+      "[fire2mongo] MongoDB not initialized. Call initMongoDB() before using any firestore functions."
+    );
+  }
+  return _db;
+}
+async function closeMongoDB() {
+  if (_client) {
+    await _client.close();
+    _client = null;
+    _db = null;
+  }
+}
+
+// src/collection-registry.ts
+var _registry = /* @__PURE__ */ new Map();
+function registerCollection(firebaseName, options) {
+  _registry.set(firebaseName, options?.mongoCollection ?? firebaseName);
+}
+function registerCollections(map) {
+  for (const [firebaseName, mongoName] of Object.entries(map)) {
+    _registry.set(firebaseName, mongoName);
+  }
+}
+function hasCollection(firebaseName) {
+  return _registry.has(firebaseName);
+}
+function getCollection(firebaseName) {
+  const mongoName = _registry.get(firebaseName);
+  if (!mongoName) {
+    const registered = [..._registry.keys()].join(", ") || "(none)";
+    throw new Error(
+      `[fire2mongo] No collection registered for "${firebaseName}". Registered: ${registered}. Call registerCollection("${firebaseName}") during app startup.`
+    );
+  }
+  return getDb().collection(mongoName);
+}
+function clearRegistry() {
+  _registry.clear();
+}
+
+// src/firestore.ts
+import { ObjectId } from "mongodb";
+
+// src/query-builder.ts
+function buildMongoFilter(constraints) {
+  const filter = {};
+  const $and = [];
+  const $or = [];
+  for (const c of constraints) {
+    if (c.type === "and" && c.queries) {
+      $and.push(...c.queries.map((q) => buildMongoFilter([q])));
+    } else if (c.type === "or" && c.queries) {
+      $or.push(...c.queries.map((q) => buildMongoFilter([q])));
+    } else if (c.type === "where" && c.field && c.operator !== void 0) {
+      applyWhere(filter, c.field, c.operator, c.value);
+    }
+  }
+  if ($and.length) filter.$and = $and;
+  if ($or.length) filter.$or = $or;
+  return filter;
+}
+function applyWhere(filter, field, op, value) {
+  switch (op) {
+    case "==":
+      filter[field] = value;
+      break;
+    case "!=":
+      filter[field] = { $ne: value };
+      break;
+    case "<":
+      filter[field] = { $lt: value };
+      break;
+    case "<=":
+      filter[field] = { $lte: value };
+      break;
+    case ">":
+      filter[field] = { $gt: value };
+      break;
+    case ">=":
+      filter[field] = { $gte: value };
+      break;
+    case "in":
+      filter[field] = { $in: value };
+      break;
+    case "not-in":
+      filter[field] = { $nin: value };
+      break;
+    case "array-contains":
+      filter[field] = { $elemMatch: { $eq: value } };
+      break;
+    case "array-contains-any":
+      filter[field] = { $in: value };
+      break;
+  }
+}
+function buildFindOptions(constraints) {
+  const options = {};
+  const sort = {};
+  for (const c of constraints) {
+    if (c.type === "orderBy" && c.field) {
+      sort[c.field] = c.direction === "desc" ? -1 : 1;
+    } else if (c.type === "limit" && c.count !== void 0) {
+      options.limit = c.count;
+    } else if (c.type === "offset" && c.count !== void 0) {
+      options.skip = c.count;
+    }
+  }
+  if (Object.keys(sort).length) {
+    options.sort = sort;
+  }
+  return options;
+}
+
+// src/snapshot.ts
+function createDocumentSnapshot(id, raw) {
+  return {
+    id,
+    exists() {
+      return raw !== null && raw !== void 0;
+    },
+    data() {
+      if (!raw) return void 0;
+      const { _id, ...rest } = raw;
+      return { ...rest, id };
+    }
+  };
+}
+function createQuerySnapshot(raws) {
+  const docs = raws.map((raw) => {
+    const id = raw._id?.toString() ?? raw.id ?? "";
+    const { _id, ...rest } = raw;
+    const docData = { ...rest, id };
+    return {
+      id,
+      exists() {
+        return true;
+      },
+      data() {
+        return docData;
+      }
+    };
+  });
+  return {
+    docs,
+    size: docs.length,
+    empty: docs.length === 0,
+    forEach(callback) {
+      docs.forEach(callback);
+    }
+  };
+}
+
+// src/field-value.ts
+var FieldValue = class {
+  constructor(type, elements) {
+    this.type = type;
+    this.elements = elements;
+  }
+};
+function arrayUnion(...elements) {
+  return new FieldValue("arrayUnion", elements);
+}
+function arrayRemove(...elements) {
+  return new FieldValue("arrayRemove", elements);
+}
+function increment(n) {
+  return new FieldValue("increment", [n]);
+}
+function buildUpdateOperators(data) {
+  const $set = {};
+  const $addToSet = {};
+  const $pull = {};
+  const $inc = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value instanceof FieldValue) {
+      switch (value.type) {
+        case "arrayUnion":
+          $addToSet[key] = { $each: value.elements };
+          break;
+        case "arrayRemove":
+          $pull[key] = { $in: value.elements };
+          break;
+        case "increment":
+          $inc[key] = value.elements[0];
+          break;
+      }
+    } else {
+      $set[key] = value;
+    }
+  }
+  const ops = {};
+  if (Object.keys($set).length) ops.$set = $set;
+  if (Object.keys($addToSet).length) ops.$addToSet = $addToSet;
+  if (Object.keys($pull).length) ops.$pull = $pull;
+  if (Object.keys($inc).length) ops.$inc = $inc;
+  return ops;
+}
+function hasFieldValues(data) {
+  return Object.values(data).some((v) => v instanceof FieldValue);
+}
+
+// src/firestore.ts
+function extractParentRefs(parentPath) {
+  if (!parentPath) return {};
+  const parts = parentPath.split("/");
+  const refs = {};
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    refs[`${parts[i]}Id`] = parts[i + 1];
+  }
+  return refs;
+}
+function resolveMongoName(fullPath) {
+  const parts = fullPath.split("/");
+  const collectionParts = [];
+  for (let i = 0; i < parts.length; i += 2) {
+    collectionParts.push(parts[i]);
+  }
+  return collectionParts.join("_");
+}
+function doc(dbOrCollection, collectionPath, ...pathSegments) {
+  if (typeof dbOrCollection === "object" && dbOrCollection.path && !collectionPath) {
+    const colRef = dbOrCollection;
+    const autoId = new ObjectId().toString();
+    return {
+      id: autoId,
+      path: `${colRef.path}/${autoId}`,
+      collection: colRef._mongoCollection,
+      _parentPath: colRef._parentPath
+    };
+  }
+  if (!collectionPath) throw new Error("[fire2mongo] doc() requires a collection path.");
+  const fullPath = [collectionPath, ...pathSegments].join("/");
+  const parts = fullPath.split("/");
+  if (parts.length < 2) throw new Error("[fire2mongo] doc() requires at least collection/id.");
+  const documentId = parts[parts.length - 1];
+  const parentPath = parts.slice(0, -1).join("/");
+  const mongoCollection = resolveMongoName(parentPath);
+  return {
+    id: documentId,
+    path: fullPath,
+    collection: mongoCollection,
+    _parentPath: parts.length > 2 ? parentPath : void 0
+  };
+}
+function collection(_db2, collectionPath, ...pathSegments) {
+  const fullPath = [collectionPath, ...pathSegments].join("/");
+  const parts = fullPath.split("/");
+  if (parts.length % 2 === 0) {
+    throw new Error(
+      `[fire2mongo] Invalid collection path "${fullPath}". Must have an odd number of segments.`
+    );
+  }
+  const mongoCollection = resolveMongoName(fullPath);
+  const parentPath = parts.length > 1 ? parts.slice(0, -1).join("/") : void 0;
+  return {
+    id: parts[parts.length - 1],
+    path: fullPath,
+    _mongoCollection: mongoCollection,
+    _parentPath: parentPath
+  };
+}
+async function getDoc(reference) {
+  try {
+    const col = getCollection(reference.collection);
+    const raw = await col.findOne({ _id: new ObjectId(reference.id) }) ?? await col.findOne({ id: reference.id });
+    return createDocumentSnapshot(reference.id, raw);
+  } catch (err) {
+    console.error("[fire2mongo] getDoc error:", err);
+    return createDocumentSnapshot(reference.id, null);
+  }
+}
+async function getDocs(queryOrRef) {
+  try {
+    let mongoCollection;
+    let constraints = [];
+    let parentPath;
+    if ("_filters" in queryOrRef) {
+      mongoCollection = queryOrRef._collectionRef._mongoCollection;
+      constraints = queryOrRef._filters;
+      parentPath = queryOrRef._collectionRef._parentPath;
+    } else {
+      mongoCollection = queryOrRef._mongoCollection;
+      parentPath = queryOrRef._parentPath;
+    }
+    const col = getCollection(mongoCollection);
+    let filter = buildMongoFilter(constraints);
+    const parentRefs = extractParentRefs(parentPath);
+    if (Object.keys(parentRefs).length) {
+      filter = { ...parentRefs, ...filter };
+    }
+    const options = buildFindOptions(constraints);
+    const raws = await col.find(filter, options).toArray();
+    return createQuerySnapshot(raws);
+  } catch (err) {
+    console.error("[fire2mongo] getDocs error:", err);
+    return createQuerySnapshot([]);
+  }
+}
+async function setDoc(reference, data, options) {
+  const col = getCollection(reference.collection);
+  const parentRefs = extractParentRefs(reference._parentPath);
+  const fullData = { ...parentRefs, ...data };
+  if (hasFieldValues(fullData)) {
+    const ops = buildUpdateOperators(fullData);
+    await col.updateOne(
+      { _id: new ObjectId(reference.id) },
+      ops,
+      { upsert: true }
+    );
+    return;
+  }
+  if (options?.merge) {
+    await col.updateOne(
+      { _id: new ObjectId(reference.id) },
+      { $set: fullData },
+      { upsert: true }
+    );
+    return;
+  }
+  await col.replaceOne(
+    { _id: new ObjectId(reference.id) },
+    { _id: new ObjectId(reference.id), ...fullData },
+    { upsert: true }
+  );
+}
+async function addDoc(reference, data) {
+  const col = getCollection(reference._mongoCollection);
+  const parentRefs = extractParentRefs(reference._parentPath);
+  const fullData = { ...parentRefs, ...data };
+  const result = await col.insertOne(fullData);
+  const newId = result.insertedId.toString();
+  return {
+    id: newId,
+    path: `${reference.path}/${newId}`,
+    collection: reference._mongoCollection,
+    _parentPath: reference._parentPath
+  };
+}
+async function updateDoc(reference, data) {
+  const col = getCollection(reference.collection);
+  const ops = hasFieldValues(data) ? buildUpdateOperators(data) : { $set: data };
+  await col.updateOne(
+    { _id: new ObjectId(reference.id) },
+    ops
+  );
+}
+async function deleteDoc(reference) {
+  const col = getCollection(reference.collection);
+  await col.deleteOne({ _id: new ObjectId(reference.id) });
+}
+function query(collectionRef, ...constraints) {
+  return { _collectionRef: collectionRef, _filters: constraints };
+}
+function where(field, op, value) {
+  return { type: "where", field, operator: op, value };
+}
+function and(...queries) {
+  return { type: "and", queries };
+}
+function or(...queries) {
+  return { type: "or", queries };
+}
+function orderBy(field, direction = "asc") {
+  return { type: "orderBy", field, direction };
+}
+function limit(count) {
+  return { type: "limit", count };
+}
+function offset(count) {
+  return { type: "offset", count };
+}
+function writeBatch(_db2) {
+  const ops = [];
+  const b = {
+    set(ref, data, options) {
+      ops.push(() => setDoc(ref, data, options));
+      return b;
+    },
+    update(ref, data) {
+      ops.push(() => updateDoc(ref, data));
+      return b;
+    },
+    delete(ref) {
+      ops.push(() => deleteDoc(ref));
+      return b;
+    },
+    async commit() {
+      await Promise.all(ops.map((op) => op()));
+    }
+  };
+  return b;
+}
+async function runTransaction(_db2, fn) {
+  const pendingWrites = [];
+  const tx = {
+    async get(ref) {
+      return getDoc(ref);
+    },
+    set(ref, data, options) {
+      pendingWrites.push(() => setDoc(ref, data, options));
+      return tx;
+    },
+    update(ref, data) {
+      pendingWrites.push(() => updateDoc(ref, data));
+      return tx;
+    },
+    delete(ref) {
+      pendingWrites.push(() => deleteDoc(ref));
+      return tx;
+    }
+  };
+  const result = await fn(tx);
+  await Promise.all(pendingWrites.map((op) => op()));
+  return result;
+}
+function getFirestore() {
+  return {};
+}
+
+// src/timestamp.ts
+var Timestamp = class _Timestamp {
+  constructor(_seconds, _nanoseconds) {
+    this._seconds = _seconds;
+    this._nanoseconds = _nanoseconds;
+  }
+  get seconds() {
+    return this._seconds;
+  }
+  get nanoseconds() {
+    return this._nanoseconds;
+  }
+  /** Current time */
+  static now() {
+    const ms = Date.now();
+    return new _Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
+  }
+  /** From a JavaScript Date */
+  static fromDate(date) {
+    const ms = date.getTime();
+    return new _Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
+  }
+  /** From epoch milliseconds */
+  static fromMillis(ms) {
+    return new _Timestamp(Math.floor(ms / 1e3), ms % 1e3 * 1e6);
+  }
+  /** Convert to JavaScript Date */
+  toDate() {
+    return new Date(this._seconds * 1e3 + this._nanoseconds / 1e6);
+  }
+  /** Convert to epoch milliseconds */
+  toMillis() {
+    return this._seconds * 1e3 + Math.floor(this._nanoseconds / 1e6);
+  }
+  isEqual(other) {
+    return this._seconds === other._seconds && this._nanoseconds === other._nanoseconds;
+  }
+  toString() {
+    return `Timestamp(seconds=${this._seconds}, nanoseconds=${this._nanoseconds})`;
+  }
+  /** MongoDB serialization — stored as Date */
+  toJSON() {
+    return this.toDate();
+  }
+  valueOf() {
+    return this.toDate();
+  }
+};
+
+// src/index.ts
+var db = {};
+export {
+  FieldValue,
+  Timestamp,
+  addDoc,
+  and,
+  arrayRemove,
+  arrayUnion,
+  clearRegistry,
+  closeMongoDB,
+  collection,
+  db,
+  deleteDoc,
+  doc,
+  getCollection,
+  getDb,
+  getDoc,
+  getDocs,
+  getFirestore,
+  hasCollection,
+  increment,
+  initMongoDB,
+  limit,
+  offset,
+  or,
+  orderBy,
+  query,
+  registerCollection,
+  registerCollections,
+  runTransaction,
+  setDoc,
+  updateDoc,
+  where,
+  writeBatch
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "fire2mongo",
+  "version": "1.0.0",
+  "description": "Drop-in TypeScript replacement for firebase/firestore backed by MongoDB",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "jest"
+  },
+  "keywords": [
+    "firebase",
+    "firestore",
+    "mongodb",
+    "migration",
+    "drop-in"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "mongodb": "^6"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "mongodb": "^6.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}