@blinkk/root-cms 2.4.9 → 2.5.1

package/dist/functions.js

@@ -1,1639 +1,15 @@
-// core/functions.ts
-import path2 from "path";
-import { loadBundledConfig } from "@blinkk/root/node";
-import { onSchedule } from "firebase-functions/v2/scheduler";
-
-// core/client.ts
-import crypto from "crypto";
-import {
-  FieldValue as FieldValue2,
-  Timestamp as Timestamp2
-} from "firebase-admin/firestore";
-
-// core/translations-manager.ts
 import {
-  FieldValue,
-  Timestamp
-} from "firebase-admin/firestore";
-
-// shared/strings.ts
-import fnv from "fnv-plus";
-function normalizeStr(str) {
-  const lines = str.trim().split("\n").map((line) => removeTrailingWhitespace(line));
-  return lines.join("\n");
-}
-function removeTrailingWhitespace(str) {
-  return str.trimEnd().replace(/ $/, "");
-}
-function hashStr(str) {
-  if (!str || typeof str !== "string") {
-    throw new Error("input string is invalid");
-  }
-  return fnv.fast1a52hex(normalizeStr(str));
-}
-
-// core/translations-manager.ts
-var TRANSLATIONS_DB_PATH_FORMAT = "/Projects/{project}/TranslationsManager/{mode}/Translations";
-var TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT = `${TRANSLATIONS_DB_PATH_FORMAT}/{id}:{locale}`;
-var TranslationsManager = class {
-  constructor(cmsClient) {
-    this.cmsClient = cmsClient;
-  }
-  /**
-   * Saves draft translations for a translations doc id.
-   *
-   * Example:
-   * ```
-   * const strings = {
-   *   'one': {es: 'uno', fr: 'un'},
-   *   'two': {es: 'dos', fr: 'deux'},
-   * };
-   * await tm.saveTranslations('Pages/index', strings);
-   * ```
-   */
-  async saveTranslations(id, strings, options) {
-    const mode = "draft";
-    const localesSet = /* @__PURE__ */ new Set();
-    Object.values(strings).forEach((entry) => {
-      Object.keys(entry).forEach((locale) => {
-        if (locale !== "source") {
-          localesSet.add(locale);
-        }
-      });
-    });
-    const batch = this.cmsClient.db.batch();
-    const locales = Array.from(localesSet);
-    locales.forEach((locale) => {
-      const updates = {
-        id,
-        locale,
-        sys: {
-          modifiedAt: Timestamp.now(),
-          modifiedBy: options?.modifiedBy || "root-cms-client"
-        },
-        strings: {}
-      };
-      if (options?.tags && options.tags.length > 0) {
-        updates.tags = FieldValue.arrayUnion(...options.tags);
-      }
-      let numUpdates = 0;
-      const hashMap = this.toLocaleDocHashMap(strings, locale);
-      Object.entries(hashMap).forEach(([hash, translations]) => {
-        Object.entries(translations).forEach(([locale2, translation]) => {
-          if (translation) {
-            updates.strings[hash] ??= {};
-            updates.strings[hash][locale2] = translation;
-            numUpdates += 1;
-          }
-        });
-      });
-      if (numUpdates > 0) {
-        const localeDocPath = buildTranslationsLocaleDocDbPath({
-          project: this.cmsClient.projectId,
-          mode,
-          id,
-          locale
-        });
-        const localeDocRef = this.cmsClient.db.doc(localeDocPath);
-        batch.set(localeDocRef, updates, { merge: true });
-      }
-    });
-    await batch.commit();
-  }
-  /**
-   * Publishes a translations doc.
-   */
-  async publishTranslations(id, options) {
-    const db = this.cmsClient.db;
-    const project = this.cmsClient.projectId;
-    const draftPath = buildTranslationsDbPath({ project, mode: "draft" });
-    const query = db.collection(draftPath).where("id", "==", id);
-    const res = await query.get();
-    if (res.size === 0) {
-      console.warn(`no translations to publish for ${id}`);
-      return;
-    }
-    const batch = options?.batch || db.batch();
-    res.docs.forEach((doc) => {
-      const translationsLocaleDoc = doc.data();
-      const sys = {
-        ...translationsLocaleDoc.sys,
-        publishedAt: Timestamp.now(),
-        publishedBy: options?.publishedBy || "root-cms-client"
-      };
-      batch.update(doc.ref, { sys });
-      const publishedDocPath = buildTranslationsLocaleDocDbPath({
-        project,
-        mode: "published",
-        id: translationsLocaleDoc.id,
-        locale: translationsLocaleDoc.locale
-      });
-      const publishedDocRef = db.doc(publishedDocPath);
-      batch.set(publishedDocRef, { ...translationsLocaleDoc, sys });
-    });
-    const shouldCommitBatch = !options?.batch;
-    if (shouldCommitBatch) {
-      await batch.commit();
-    }
-  }
-  /**
-   * Fetches translations from one or more translations docs in the translations
-   * manager.
-   *
-   * Example:
-   * ```
-   * await tm.loadTranslations();
-   * // =>
-   * // {
-   * //   "one": {"es": "uno", "fr": "un"},
-   * //   "two": {"es": "dos", "fr": "deux"}
-   * // }
-   * ```
-   *
-   * To load a specific set of translations docs by id:
-   * ```
-   * const translationsToLoad = ['Global/strings', 'Global/header', 'Global/footer', 'Pages/index'];
-   * await tm.loadTranslations({ids: translationsToLoad});
-   * // =>
-   * // {
-   * //   "one": {"es": "uno", "fr": "un"},
-   * //   "two": {"es": "dos", "fr": "deux"}
-   * // }
-   * ```
-   *
-   * To load a subset of locales (more performant):
-   * ```
-   * await tm.loadTranslations({locales: ['es']});
-   * // =>
-   * // {
-   * //   "one": {"es": "uno"},
-   * //   "two": {"es": "dos"}
-   * // }
-   * ```
-   */
-  async loadTranslations(options) {
-    const mode = options?.mode || "published";
-    const dbPath = buildTranslationsDbPath({
-      project: this.cmsClient.projectId,
-      mode
-    });
-    let query = this.cmsClient.db.collection(dbPath);
-    if (options?.ids && options.ids.length > 0) {
-      query = query.where("id", "in", options.ids);
-    }
-    if (options?.tags && options.tags.length > 0) {
-      query = query.where("tags", "array-contains", options.tags);
-    }
-    if (options?.locales && options.locales.length > 0) {
-      query = query.where("locale", "in", options.locales);
-    }
-    const results = await query.get();
-    const strings = {};
-    results.forEach((result) => {
-      const localeDoc = result.data();
-      Object.values(localeDoc.strings || {}).forEach((item) => {
-        strings[item.source] ??= { source: item.source };
-        strings[item.source][localeDoc.locale] = item.translation;
-      });
-    });
-    return strings;
-  }
-  /**
-   * Fetches translations for a given locale, with optional fallbacks.
-   * The return value is a map of source string to translated string.
-   *
-   * Example:
-   * ```
-   * await translationsDoc.loadTranslationsForLocale('es');
-   * // =>
-   * // {
-   * //   "one": "uno",
-   * //   "two": "dos",
-   * // }
-   * ```
-   */
-  async loadTranslationsForLocale(locale, options) {
-    const localeSet = /* @__PURE__ */ new Set([
-      locale,
-      ...options?.fallbackLocales || []
-    ]);
-    const fallbackLocales = Array.from(localeSet);
-    const multiLocaleStrings = await this.loadTranslations({
-      mode: options?.mode,
-      locales: fallbackLocales
-    });
-    return this.toSingleLocaleMap(multiLocaleStrings, fallbackLocales);
-  }
-  /**
-   * Converts a multi-locale translations map to a flat single-locale map,
-   * with optional support for fallback locales.
-   *
-   * ```
-   * const multiLocaleStrings = {
-   *   'one': {es: 'uno', fr: 'un'},
-   *   'two': {es: 'dos', fr: 'deux'}
-   * };
-   * translationsDoc.toSingleLocaleMap(multiLocaleStrings, ['es']);
-   * // =>
-   * // {
-   * //   "one": "uno",
-   * //   "two": "dos",
-   * // }
-   * ```
-   */
-  toSingleLocaleMap(multiLocaleStrings, fallbackLocales) {
-    const singleLocaleStrings = {};
-    Object.entries(multiLocaleStrings).forEach(([source, translations]) => {
-      let translation = source;
-      for (const locale of fallbackLocales) {
-        if (translations[locale]) {
-          translation = translations[locale];
-          break;
-        }
-      }
-      singleLocaleStrings[source] = translation;
-    });
-    return singleLocaleStrings;
-  }
-  /**
-   * Converts a multi-locale translations map to a single-locale hashed version,
-   * used for storage in in the DB.
-   *
-   * ```
-   * const multiLocaleStrings = {
-   *   'one': {es: 'uno', fr: 'un'},
-   *   'two': {es: 'dos', fr: 'deux'}
-   * };
-   * translationsDoc.toLocaleDocHashMap(multiLocaleStrings, 'es');
-   * // =>
-   * // {
-   * //   "<hash1>": {"source": "one", "translation": "uno"},
-   * //   "<hash2>": {"source": "two", "translation": "dos"},
-   * // }
-   * ```
-   *
-   * One reason for using hashes is because the DB has limits on the number of
-   * chars that can be used as the "key" in a object map.
-   */
-  toLocaleDocHashMap(multiLocaleStrings, locale) {
-    const hashMap = {};
-    Object.entries(multiLocaleStrings).forEach(([source, translations]) => {
-      const translation = translations[locale];
-      if (translation) {
-        const hash = hashStr(source);
-        hashMap[hash] = { source, translation };
-      }
-    });
-    return hashMap;
-  }
-  /**
-   * Import translations from the v1 system to the TranslationsManager.
-   */
-  async importTranslationsFromV1() {
-    const projectId = this.cmsClient.projectId;
-    const db = this.cmsClient.db;
-    const dbPath = `Projects/${projectId}/Translations`;
-    const query = db.collection(dbPath);
-    const querySnapshot = await query.get();
-    if (querySnapshot.size === 0) {
-      return;
-    }
-    console.log(
-      "[root cms] importing v1 Translations to v2 TranslationsManager"
-    );
-    const translationsDocs = {};
-    querySnapshot.forEach((doc) => {
-      const translation = doc.data();
-      const source = this.cmsClient.normalizeString(translation.source);
-      delete translation.source;
-      const tags = translation.tags || [];
-      delete translation.tags;
-      for (const tag of tags) {
-        if (tag.includes("/")) {
-          const translationsId = tag;
-          translationsDocs[translationsId] ??= {
-            id: translationsId,
-            tags,
-            strings: {}
-          };
-          translationsDocs[translationsId].strings[source] = translation;
-        }
-      }
-    });
-    if (Object.keys(translationsDocs).length === 0) {
-      console.log("[root cms] no v1 translations to save");
-      return;
-    }
-    for (const docId in translationsDocs) {
-      const [collection, slug] = docId.split("/");
-      if (collection && slug) {
-        const doc = await this.cmsClient.getDoc(collection, slug, {
-          mode: "draft"
-        });
-        const linkedSheet = doc?.sys?.l10nSheet;
-        if (linkedSheet) {
-          translationsDocs[docId].sys.linkedSheet = linkedSheet;
-        }
-      }
-    }
-    Object.entries(translationsDocs).forEach(([translationsId, data]) => {
-      const len = Object.keys(data.strings).length;
-      console.log(`[root cms] saving ${len} string(s) to ${translationsId}...`);
-      this.saveTranslations(translationsId, data.strings, {
-        tags: data.tags || [translationsId]
-      });
-    });
-  }
-};
-function buildTranslationsDbPath(options) {
-  return TRANSLATIONS_DB_PATH_FORMAT.replace(
-    "{project}",
-    options.project
-  ).replace("{mode}", options.mode);
-}
-function buildTranslationsLocaleDocDbPath(options) {
-  return TRANSLATIONS_LOCALE_DOC_DB_PATH_FORMAT.replace(
-    "{project}",
-    options.project
-  ).replace("{mode}", options.mode).replace("{id}", options.id.replaceAll("/", "--")).replace("{locale}", options.locale);
-}
-
-// core/client.ts
-var RootCMSClient = class {
-  constructor(rootConfig) {
-    this.rootConfig = rootConfig;
-    this.cmsPlugin = getCmsPlugin(this.rootConfig);
-    const cmsPluginOptions = this.cmsPlugin.getConfig();
-    this.projectId = cmsPluginOptions.id || "default";
-    this.app = this.cmsPlugin.getFirebaseApp();
-    this.db = this.cmsPlugin.getFirestore();
-  }
-  /**
-   * Retrieves doc data from Root.js CMS.
-   */
-  async getDoc(collectionId, slug, options) {
-    const rawData = await this.getRawDoc(collectionId, slug, options);
-    if (rawData) {
-      return unmarshalData(rawData);
-    }
-    return null;
-  }
-  /**
-   * Retrieves raw doc data as stored in the database. Only use this if you know
-   * what you are doing.
-   */
-  async getRawDoc(collectionId, slug, options) {
-    const mode = options.mode;
-    const modeCollection = mode === "draft" ? "Drafts" : "Published";
-    slug = slug.replaceAll("/", "--");
-    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;
-    const docRef = this.db.doc(dbPath);
-    const doc = await docRef.get();
-    if (doc.exists) {
-      return doc.data();
-    }
-    return null;
-  }
-  /**
-   * Firestore path for a collection.
-   */
-  dbCollectionDocsPath(collectionId, options) {
-    let modeCollection = "";
-    if (options.mode === "draft") {
-      modeCollection = "Drafts";
-    } else if (options.mode === "published") {
-      modeCollection = "Published";
-    } else {
-      throw new Error(`unknown mode: ${options.mode}`);
-    }
-    return `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;
-  }
-  /**
-   * Firestore path for a content doc.
-   */
-  dbDocPath(collectionId, slug, options) {
-    const collectionDocsPath = this.dbCollectionDocsPath(collectionId, options);
-    const normalizedSlug = slug.replaceAll("/", "--");
-    return `${collectionDocsPath}/${normalizedSlug}`;
-  }
-  /**
-   * Firestore doc ref for a content doc.
-   */
-  dbDocRef(collectionId, slug, options) {
-    const docPath = this.dbDocPath(collectionId, slug, options);
-    return this.db.doc(docPath);
-  }
-  /**
-   * Saves draft data to a doc.
-   *
-   * Note: this saves data to the "fields" attr of the draft doc. If you need to
-   * modify the sys-level attributes of the doc, use `setRawDoc()`.
-   */
-  async saveDraftData(docId, fieldsData, options) {
-    const { collection, slug } = parseDocId(docId);
-    const draftDoc = await this.getRawDoc(collection, slug, { mode: "draft" }) || {};
-    const draftSys = draftDoc.sys || {};
-    const modifiedBy = options?.modifiedBy || "root-cms-client";
-    const fields = marshalData(fieldsData || {});
-    const data = {
-      id: docId,
-      collection,
-      slug,
-      sys: {
-        ...draftSys,
-        createdAt: draftSys.createdAt ?? Timestamp2.now(),
-        createdBy: draftSys.createdBy ?? modifiedBy,
-        modifiedAt: Timestamp2.now(),
-        modifiedBy,
-        locales: options?.locales ?? draftSys.locales ?? ["en"]
-      },
-      fields
-    };
-    await this.setRawDoc(collection, slug, data, { mode: "draft" });
-  }
-  /**
-   * Prefer `saveDraftData('Pages/foo', data)`. Only use this if you know what
-   * you're doing.
-   */
-  async setRawDoc(collectionId, slug, data, options) {
-    const mode = options.mode;
-    const modeCollection = mode === "draft" ? "Drafts" : "Published";
-    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}/${slug}`;
-    const docRef = this.db.doc(dbPath);
-    await docRef.set(data);
-  }
-  /**
-   * Lists docs from a Root.js CMS collection.
-   */
-  async listDocs(collectionId, options) {
-    const mode = options.mode;
-    const modeCollection = mode === "draft" ? "Drafts" : "Published";
-    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;
-    let query = this.db.collection(dbPath);
-    if (options.limit) {
-      query = query.limit(options.limit);
-    }
-    if (options.offset) {
-      query = query.offset(options.offset);
-    }
-    if (options.orderBy) {
-      query = query.orderBy(options.orderBy, options.orderByDirection);
-    }
-    if (options.query) {
-      query = options.query(query);
-    }
-    const results = await query.get();
-    const docs = [];
-    results.forEach((result) => {
-      if (options.raw) {
-        const rawDoc = result.data();
-        docs.push(rawDoc);
-      } else {
-        const doc = unmarshalData(result.data());
-        docs.push(doc);
-      }
-    });
-    return { docs };
-  }
-  /**
-   * Returns the number of docs in a Root.js CMS collection.
-   */
-  async getDocsCount(collectionId, options) {
-    const mode = options.mode;
-    const modeCollection = mode === "draft" ? "Drafts" : "Published";
-    const dbPath = `Projects/${this.projectId}/Collections/${collectionId}/${modeCollection}`;
-    let query = this.db.collection(dbPath);
-    if (options.query) {
-      query = options.query(query);
-    }
-    const results = await query.count().get();
-    const count = results.data().count;
-    return count;
-  }
-  /**
-   * Batch publishes a set of docs by id.
-   */
-  async publishDocs(docIds, options) {
-    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;
-    const publishedBy = options?.publishedBy || "root-cms-client";
-    const docRefs = docIds.map((docId) => {
-      const [collection, slug] = docId.split("/");
-      if (!collection || !slug) {
-        throw new Error(`invalid doc id: ${docId}`);
-      }
-      const docRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Drafts/${slug}`
-      );
-      return docRef;
-    });
-    const docSnapshots = await this.db.getAll(...docRefs);
-    const docs = docSnapshots.map((snapshot) => snapshot.data()).filter((d) => !!d);
-    if (docs.length === 0) {
-      console.log("no docs to publish");
-      return [];
-    }
-    for (const doc of docs) {
-      if (this.testPublishingLocked(doc)) {
-        throw new Error(`publishing is locked for doc: ${doc.id}`);
-      }
-    }
-    let batchCount = 0;
-    const batch = options?.batch || this.db.batch();
-    const versionTags = ["published"];
-    if (options?.releaseId) {
-      versionTags.push(`release:${options.releaseId}`);
-    }
-    const publishedDocs = [];
-    for (const doc of docs) {
-      const { id, collection, slug, sys, fields } = doc;
-      const draftRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Drafts/${slug}`
-      );
-      const scheduledRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`
-      );
-      const publishedRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Published/${slug}`
-      );
-      const firstPublishedAt = sys.firstPublishedAt ?? FieldValue2.serverTimestamp();
-      const firstPublishedBy = sys.firstPublishedBy ?? publishedBy;
-      batch.set(publishedRef, {
-        id,
-        collection,
-        slug,
-        fields: fields || {},
-        sys: {
-          ...sys,
-          firstPublishedAt,
-          firstPublishedBy,
-          publishedAt: FieldValue2.serverTimestamp(),
-          publishedBy
-        }
-      });
-      batchCount += 1;
-      const versionRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Drafts/${slug}/Versions/${Date.now()}`
-      );
-      const versionData = {
-        id,
-        collection,
-        slug,
-        fields: fields || {},
-        sys: {
-          ...sys,
-          firstPublishedAt,
-          firstPublishedBy,
-          publishedAt: FieldValue2.serverTimestamp(),
-          publishedBy
-        }
-      };
-      if (versionTags.length) {
-        versionData.tags = versionTags;
-      }
-      batch.set(versionRef, versionData);
-      batchCount += 1;
-      batch.delete(scheduledRef);
-      batchCount += 1;
-      batch.update(draftRef, {
-        "sys.scheduledAt": FieldValue2.delete(),
-        "sys.scheduledBy": FieldValue2.delete(),
-        "sys.firstPublishedAt": firstPublishedAt,
-        "sys.firstPublishedBy": firstPublishedBy,
-        "sys.publishedAt": FieldValue2.serverTimestamp(),
-        "sys.publishedBy": publishedBy
-      });
-      batchCount += 1;
-      publishedDocs.push(doc);
-      if (batchCount >= 400) {
-        await batch.commit();
-        batchCount = 0;
-      }
-    }
-    if (batchCount > 0) {
-      await batch.commit();
-    }
-    console.log(`published ${publishedDocs.length} docs!`);
-    return publishedDocs;
-  }
-  /**
-   * Publishes scheduled docs.
-   */
-  async publishScheduledDocs() {
-    const projectCollectionsPath = `Projects/${this.projectId}/Collections`;
-    const now = Math.ceil((/* @__PURE__ */ new Date()).getTime());
-    const snapshot = await this.db.collectionGroup("Scheduled").get();
-    const docs = snapshot.docs.filter((d) => {
-      if (!d.ref.path.startsWith(projectCollectionsPath)) {
-        return false;
-      }
-      const data = d.data() || {};
-      const scheduledAt = data.sys?.scheduledAt;
-      return scheduledAt && scheduledAt.toMillis && scheduledAt.toMillis() <= now;
-    }).map((d) => {
-      const dbPath = d.ref.path;
-      const segments = dbPath.split("/");
-      const slug = segments.at(-1);
-      const collection = segments.at(-3);
-      const id = `${collection}/${slug}`;
-      return {
-        data: d.data(),
-        id,
-        collection,
-        slug
-      };
-    });
-    if (docs.length === 0) {
-      console.log("no docs to schedule");
-      return [];
-    }
-    let batchCount = 0;
-    const batch = this.db.batch();
-    const versionTags = ["published"];
-    const publishedDocs = [];
-    for (const doc of docs) {
-      const { id, collection, slug, data } = doc;
-      const draftRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Drafts/${slug}`
-      );
-      const scheduledRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Scheduled/${slug}`
-      );
-      const publishedRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Published/${slug}`
-      );
-      const { scheduledAt, scheduledBy, ...sys } = data.sys || {};
-      const firstPublishedAt = sys.firstPublishedAt ?? scheduledAt;
-      const firstPublishedBy = sys.firstPublishedBy ?? (scheduledBy || "root-cms-client");
-      batch.set(publishedRef, {
-        id,
-        collection,
-        slug,
-        fields: data.fields || {},
-        sys: {
-          ...sys,
-          firstPublishedAt,
-          firstPublishedBy,
-          publishedAt: FieldValue2.serverTimestamp(),
-          publishedBy: scheduledBy || ""
-        }
-      });
-      batchCount += 1;
-      const versionRef = this.db.doc(
-        `${projectCollectionsPath}/${collection}/Drafts/${slug}/Versions/${Date.now()}`
-      );
-      const versionData = {
-        id,
-        collection,
-        slug,
-        fields: data.fields || {},
-        sys: {
-          ...sys,
-          firstPublishedAt,
-          firstPublishedBy,
-          publishedAt: FieldValue2.serverTimestamp(),
-          publishedBy: scheduledBy || ""
-        },
-        tags: versionTags
-      };
-      batch.set(versionRef, versionData);
-      batchCount += 1;
-      batch.delete(scheduledRef);
-      batchCount += 1;
-      batch.update(draftRef, {
-        "sys.scheduledAt": FieldValue2.delete(),
-        "sys.scheduledBy": FieldValue2.delete(),
-        "sys.firstPublishedAt": firstPublishedAt,
-        "sys.firstPublishedBy": firstPublishedBy,
-        "sys.publishedAt": FieldValue2.serverTimestamp(),
-        "sys.publishedBy": scheduledBy || "root-cms-client"
-      });
-      batchCount += 1;
-      publishedDocs.push(doc);
-      if (batchCount >= 400) {
-        await batch.commit();
-        batchCount = 0;
-        continue;
-      }
-    }
-    if (batchCount > 0) {
-      await batch.commit();
-    }
-    console.log(`published ${publishedDocs.length} docs!`);
-    return publishedDocs;
-  }
-  /**
-   * Publishes docs in scheduled releases.
-   */
-  async publishScheduledReleases() {
-    const releasesPath = `Projects/${this.projectId}/Releases`;
-    const now = Math.ceil((/* @__PURE__ */ new Date()).getTime());
-    const query = this.db.collection(releasesPath).where("scheduledAt", "<=", Timestamp2.fromMillis(now));
-    const querySnapshot = await query.get();
-    for (const snapshot of querySnapshot.docs) {
-      const release = snapshot.data();
-      const batch = this.db.batch();
-      const publishedBy = release.scheduledBy || "root-cms-client";
-      batch.update(snapshot.ref, {
-        publishedAt: Timestamp2.now(),
-        publishedBy,
-        scheduledAt: FieldValue2.delete(),
-        scheduledBy: FieldValue2.delete()
-      });
-      const dataSourceIds = release.dataSourceIds || [];
-      if (dataSourceIds.length > 0) {
-        await this.publishDataSources(dataSourceIds, {
-          publishedBy,
-          batch,
-          commitBatch: false
-        });
-      }
-      await this.publishDocs(release.docIds || [], {
-        publishedBy,
-        batch,
-        releaseId: release.id
-      });
-    }
-  }
-  /**
-   * Checks if a doc is currently "locked" for publishing.
-   */
-  testPublishingLocked(doc) {
-    if (doc.sys?.publishingLocked) {
-      if (doc.sys.publishingLocked.until) {
-        const now = Timestamp2.now().toMillis();
-        const until = doc.sys.publishingLocked.until.toMillis();
-        return now < until;
-      }
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Returns a `TranslationsManager` object for managing translations.
-   *
-   * To get translations:
-   * ```
-   * await tm.loadTranslations({
-   *   ids: ['Global/strings', 'Pages/index'],
-   *   locales: ['es'],
-   * });
-   * ```
-   *
-   * NOTE: The `TranslationsManager` is a v2 feature that will eventually
-   * replace the v1 translations system.
-   */
-  getTranslationsManager() {
-    const cmsPluginOptions = this.cmsPlugin.getConfig();
-    if (cmsPluginOptions.experiments?.v2TranslationsManager) {
-      throw new Error(
-        "`v2TranslationsManager` is not enabled. update root.config.ts and add: `{experiments: {v2TranslationsManager: true}}`"
-      );
-    }
-    return new TranslationsManager(this);
-  }
-  /**
-   * Loads translations saved in the translations collection, optionally
-   * filtered by tag.
-   *
-   * Returns a map like:
-   * ```
-   * {
-   *   "<hash>": {"source": "Hello", "es": "Hola", "fr": "Bonjour"},
-   * }
-   * ```
-   */
-  async loadTranslations(options) {
-    const dbPath = `Projects/${this.projectId}/Translations`;
-    let query = this.db.collection(dbPath);
-    if (options?.tags) {
-      query = query.where("tags", "array-contains-any", options.tags);
-    }
-    const querySnapshot = await query.get();
-    const translationsMap = {};
-    querySnapshot.forEach((doc) => {
-      const hash = doc.id;
-      translationsMap[hash] = doc.data();
-    });
-    return translationsMap;
-  }
-  /**
-   * Saves a map of translations, e.g.:
-   * ```
-   * await client.saveTranslations({
-   *   "Hello": {"es": "Hola", "fr": "Bonjour"},
-   * });
-   * ```
-   */
-  async saveTranslations(translations, tags) {
-    const translationsPath = `Projects/${this.projectId}/Translations`;
-    const batch = this.db.batch();
-    let batchCount = 0;
-    Object.entries(translations).forEach(([source, sourceTranslations]) => {
-      const hash = this.getTranslationKey(source);
-      const translationRef = this.db.doc(`${translationsPath}/${hash}`);
-      const data = {
-        ...sourceTranslations,
-        source: this.normalizeString(source)
-      };
-      if (tags) {
-        data.tags = FieldValue2.arrayUnion(...tags);
-      }
-      batch.set(translationRef, data, { merge: true });
-      batchCount += 1;
-    });
-    if (batchCount > 500) {
-      throw new Error("up to 500 translations can be saved at a time.");
-    }
-    await batch.commit();
-  }
-  /**
-   * Returns the "key" used for a translation as stored in the db. Translations
-   * are stored under `Projects/<project id>/Translations/<sha1 hash>`.
-   */
-  getTranslationKey(source) {
-    const sha1 = crypto.createHash("sha1").update(this.normalizeString(source)).digest("hex");
-    return sha1;
-  }
-  /**
-   * Cleans a string that's used for translations. Performs the following:
-   * - Removes any leading/trailing whitespace
-   * - Removes spaces at the end of any line
-   */
-  normalizeString(str) {
-    const lines = String(str).trim().split("\n").map((line) => line.trimEnd());
-    return lines.join("\n");
-  }
-  /**
-   * Loads translations for a particular locale.
-   *
-   * Returns a map like:
-   * ```
-   * {
-   *   "Hello": "Bonjour",
-   * }
-   * ```
-   */
-  async loadTranslationsForLocale(locale, options) {
-    const translationsMap = await this.loadTranslations(options);
-    return translationsForLocale(translationsMap, locale);
-  }
-  /**
-   * Firestore path for a translations file.
-   */
-  dbTranslationsPath(translationsId, options) {
-    const mode = options.mode;
-    if (!(mode === "draft" || mode === "published")) {
-      throw new Error(`invalid mode: ${mode}`);
-    }
-    const slug = translationsId.replaceAll("/", "--");
-    const dbPath = `Projects/${this.projectId}/TranslationsManager/${mode}/Translations/${slug}`;
-    return dbPath;
-  }
-  /**
-   * Firestore doc ref for a translations file.
-   */
-  dbTranslationsRef(translationsId, options) {
-    const dbPath = this.dbTranslationsPath(translationsId, options);
-    return this.db.doc(dbPath);
-  }
-  /**
-   * Returns a data source configuration object.
-   */
-  async getDataSource(dataSourceId) {
-    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;
-    const docRef = this.db.doc(dbPath);
-    const doc = await docRef.get();
-    if (doc.exists) {
-      return doc.data();
-    }
-    return null;
-  }
-  /**
-   * Syncs a data source to draft state.
-   */
-  async syncDataSource(dataSourceId, options) {
-    const dataSource = await this.getDataSource(dataSourceId);
-    if (!dataSource) {
-      throw new Error(`data source not found: ${dataSourceId}`);
-    }
-    const data = await this.fetchData(dataSource);
-    const dataSourceDocRef = this.db.doc(
-      `Projects/${this.projectId}/DataSources/${dataSourceId}`
-    );
-    const dataDocRef = this.db.doc(
-      `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/draft`
-    );
-    const syncedBy = options?.syncedBy || "root-cms-client";
-    const updatedDataSource = {
-      ...dataSource,
-      syncedAt: Timestamp2.now(),
-      syncedBy
-    };
-    const batch = this.db.batch();
-    batch.set(dataDocRef, {
-      dataSource: updatedDataSource,
-      data
-    });
-    batch.update(dataSourceDocRef, {
-      syncedAt: Timestamp2.now(),
-      syncedBy
-    });
-    await batch.commit();
-    console.log(`synced data source: ${dataSourceId}`);
-    console.log(`synced by: ${syncedBy}`);
-  }
-  async publishDataSource(dataSourceId, options) {
-    const dataSource = await this.getDataSource(dataSourceId);
-    if (!dataSource) {
-      throw new Error(`data source not found: ${dataSourceId}`);
-    }
-    const dataSourceDocRef = this.db.doc(
-      `Projects/${this.projectId}/DataSources/${dataSourceId}`
-    );
-    const dataDocRefDraft = this.db.doc(
-      `Projects/${this.projectId}/DataSources/${dataSourceId}/draft`
-    );
-    const dataDocRefPublished = this.db.doc(
-      `Projects/${this.projectId}/DataSources/${dataSourceId}/published`
-    );
-    const dataRes = await this.getFromDataSource(dataSourceId, { mode: "draft" });
-    const publishedBy = options?.publishedBy || "root-cms-client";
-    const updatedDataSource = {
-      ...dataSource,
-      publishedAt: Timestamp2.now(),
-      publishedBy
-    };
-    const batch = this.db.batch();
-    batch.set(dataDocRefPublished, {
-      dataSource: updatedDataSource,
-      data: dataRes?.data || null,
-      ...dataRes?.headers ? { headers: dataRes.headers } : {}
-    });
-    batch.update(dataDocRefDraft, {
-      dataSource: updatedDataSource
-    });
-    batch.update(dataSourceDocRef, {
-      publishedAt: Timestamp2.now(),
-      publishedBy
-    });
-    await batch.commit();
-    console.log(`published data ${dataSourceId}`);
-    console.log(`published by: ${publishedBy}`);
-  }
-  async publishDataSources(dataSourceIds, options) {
-    const publishedBy = options?.publishedBy || "root-cms-client";
-    const batch = options?.batch || this.db.batch();
-    for (const id of dataSourceIds) {
-      const dataSource = await this.getDataSource(id);
-      if (!dataSource) {
-        throw new Error(`data source not found: ${id}`);
-      }
-      const dataSourceDocRef = this.db.doc(
-        `Projects/${this.projectId}/DataSources/${id}`
-      );
-      const dataDocRefDraft = this.db.doc(
-        `Projects/${this.projectId}/DataSources/${id}/draft`
-      );
-      const dataDocRefPublished = this.db.doc(
-        `Projects/${this.projectId}/DataSources/${id}/published`
-      );
-      const dataRes = await this.getFromDataSource(id, { mode: "draft" });
-      const updatedDataSource = {
-        ...dataSource,
-        publishedAt: FieldValue2.serverTimestamp(),
-        publishedBy
-      };
-      batch.set(dataDocRefPublished, {
-        dataSource: updatedDataSource,
-        data: dataRes?.data || null,
-        ...dataRes?.headers ? { headers: dataRes.headers } : {}
-      });
-      batch.update(dataDocRefDraft, { dataSource: updatedDataSource });
-      batch.update(dataSourceDocRef, {
-        publishedAt: FieldValue2.serverTimestamp(),
-        publishedBy
-      });
-    }
-    if (!options?.batch || options?.commitBatch) {
-      await batch.commit();
-    }
-  }
-  async fetchData(dataSource) {
-    if (dataSource.type === "http") {
-      return await this.fetchHttpData(dataSource);
-    }
-    throw new Error(`unsupported data source: ${dataSource.type}`);
-  }
-  async fetchHttpData(dataSource) {
-    const url = dataSource.url || "";
-    if (!url.startsWith("https://")) {
-      throw new Error(`url not supported: ${url}`);
-    }
-    const res = await fetch(url, {
-      method: dataSource.httpOptions?.method || "GET",
-      headers: dataSource.httpOptions?.headers || [],
-      body: dataSource.httpOptions?.body || void 0
-    });
-    if (res.status !== 200) {
-      const err = await res.text();
-      throw new Error(`req failed: ${err}`);
-    }
-    const contentType = String(res.headers.get("content-type"));
-    if (contentType.includes("application/json")) {
-      return await res.json();
-    }
-    return res.text();
-  }
-  /**
-   * Fetches data from a data source.
-   */
-  async getFromDataSource(dataSourceId, options) {
-    const mode = options?.mode || "published";
-    if (!(mode === "draft" || mode === "published")) {
-      throw new Error(`invalid mode: ${mode}`);
-    }
-    if (!dataSourceId || dataSourceId.includes("/")) {
-      throw new Error(`invalid data source id: ${dataSourceId}`);
-    }
-    const docRef = this.dbDataSourceDataRef(dataSourceId, { mode });
-    const doc = await docRef.get();
-    if (doc.exists) {
-      return doc.data();
-    }
-    return null;
-  }
-  /**
-   * Firestore path for a datasource data.
-   */
-  dbDataSourceDataPath(dataSourceId, options) {
-    if (!dataSourceId || dataSourceId.includes("/")) {
-      throw new Error(`invalid data source id: ${dataSourceId}`);
-    }
-    const mode = options.mode;
-    if (!(mode === "draft" || mode === "published")) {
-      throw new Error(`invalid mode: ${mode}`);
-    }
-    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/${mode}`;
-    return dbPath;
-  }
-  /**
-   * Firestore doc ref for a datasource data.
-   */
-  dbDataSourceDataRef(dataSourceId, options) {
-    const dbPath = this.dbDataSourceDataPath(dataSourceId, options);
-    return this.db.doc(dbPath);
-  }
-  /**
-   * Gets the user's role from the project's ACL.
-   */
-  async getUserRole(email) {
-    if (!email) {
-      return null;
-    }
-    const docRef = this.db.doc(`Projects/${this.projectId}`);
-    const snapshot = await docRef.get();
-    const data = snapshot.data() || {};
-    const acl = data.roles || {};
-    if (email in acl) {
-      return acl[email];
-    }
-    if (!email.includes("@")) {
-      console.warn(`invalid email: ${email}`);
-      return null;
-    }
-    const domain = email.split("@").at(-1);
-    if (domain && `*@${domain}` in acl) {
-      return acl[`*@${domain}`];
-    }
-    return null;
-  }
-  /**
-   * Verifies user exists in the ACL list.
-   */
-  async userExistsInAcl(email) {
-    if (!email) {
-      return false;
-    }
-    const docRef = this.db.doc(`Projects/${this.projectId}`);
-    const snapshot = await docRef.get();
-    const data = snapshot.data() || {};
-    const acl = data.roles || {};
-    if (email in acl) {
-      return true;
-    }
-    if (!email.includes("@")) {
-      console.warn(`invalid email: ${email}`);
-      return false;
-    }
-    const domain = email.split("@").at(-1);
-    if (domain && `*@${domain}` in acl) {
-      return true;
-    }
-    return false;
-  }
-  async logAction(action, options) {
-    if (!action) {
-      throw new Error('missing required: "action"');
-    }
-    const data = {
-      action,
-      timestamp: Timestamp2.now(),
-      by: options?.by || "system",
-      metadata: options?.metadata || {}
-    };
-    if (options?.links) {
-      data.links = options.links;
-    }
-    const colRef = this.db.collection(`Projects/${this.projectId}/ActionLogs`);
-    await colRef.add(data);
-    const metaStr = options?.metadata ? stringifyObj(options.metadata) : "";
-    console.log(`[${data.timestamp.toMillis()}] action: ${action} ${metaStr}`);
-    const cmsPluginConfig = this.cmsPlugin.getConfig();
-    if (cmsPluginConfig.onAction) {
-      try {
-        cmsPluginConfig.onAction(data);
-      } catch (err) {
-        console.error(err);
-      }
-    }
-  }
-  /**
-   * Creates a batch request that is capable of fetching one or more docs,
-   * corresponding translations, and dataSources.
-   */
-  createBatchRequest(options) {
-    return new BatchRequest(this, options);
-  }
-};
-function isRichTextData(data) {
-  return Boolean(
-    isObject(data) && Array.isArray(data.blocks) && data.time && data.version
-  );
-}
-function getCmsPlugin(rootConfig) {
-  const plugins = rootConfig.plugins || [];
-  const plugin = plugins.find((plugin2) => plugin2.name === "root-cms");
-  if (!plugin) {
-    throw new Error("could not find root-cms plugin config in root.config.ts");
-  }
-  return plugin;
-}
-function marshalData(data) {
-  if (isRichTextData(data)) {
-    return data;
-  }
-  const result = {};
-  for (const key in data) {
-    const val = data[key];
-    if (isObject(val)) {
-      result[key] = marshalData(val);
-    } else if (Array.isArray(val)) {
-      if (val.length > 0 && val.some((item) => isObject(item))) {
-        const items = val.map((item) => {
-          if (isObject(item)) {
-            return marshalData(item);
-          }
-          return item;
-        });
-        result[key] = toArrayObject(items);
-      } else {
-        result[key] = val;
-      }
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function unmarshalData(data) {
-  const result = {};
-  for (const key in data) {
-    const val = data[key];
-    if (isObject(val)) {
-      if (val.toMillis) {
-        result[key] = val.toMillis();
-      } else if (Object.hasOwn(val, "_array") && Array.isArray(val._array)) {
-        const arr = val._array.map((arrayKey) => {
-          return {
-            ...unmarshalData(val[arrayKey] || {}),
-            _arrayKey: arrayKey
-          };
-        });
-        result[key] = arr;
-      } else {
-        result[key] = unmarshalData(val);
-      }
-    } else {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function toArrayObject(arr) {
-  if (!Array.isArray(arr)) {
-    return arr;
-  }
-  const arrObject = { _array: [] };
-  for (const item of arr) {
-    const key = randString(6);
-    arrObject[key] = item;
-    arrObject._array.push(key);
-  }
-  return arrObject;
-}
-function isObject(data) {
-  return typeof data === "object" && !Array.isArray(data) && data !== null;
-}
-function randString(len) {
-  const result = [];
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  for (let i = 0; i < len; i++) {
-    const rand = Math.floor(Math.random() * chars.length);
-    result.push(chars.charAt(rand));
-  }
-  return result.join("");
-}
-function translationsForLocale(translationsMap, locale) {
-  const localeTranslations = {};
-  Object.values(translationsMap).forEach((string) => {
-    const source = string.source;
-    const translation = string[locale] || string.en || string.source;
-    localeTranslations[source] = translation;
-  });
-  return localeTranslations;
-}
-function stringifyObj(obj) {
-  function format(obj2) {
-    if (obj2 === null) {
-      return "null";
-    }
-    if (typeof obj2 === "undefined") {
-      return "undefined";
-    }
-    if (typeof obj2 === "string") {
-      return `"${obj2.replaceAll('"', '\\"')}"`;
-    }
-    if (typeof obj2 !== "object") {
-      return String(obj2);
-    }
-    if (Array.isArray(obj2)) {
-      return `[${obj2.map(format).join(", ")}]`;
-    }
-    const entries = Object.entries(obj2).map(([key, value]) => {
-      return `${key}: ${format(value)}`;
-    });
-    return `{${entries.join(", ")}}`;
-  }
-  return format(obj);
-}
-function parseDocId(docId) {
-  const sepIndex = docId.indexOf("/");
-  if (sepIndex <= 0) {
-    throw new Error(`invalid doc id: ${docId}`);
-  }
-  const collection = docId.slice(0, sepIndex);
-  const slug = docId.slice(sepIndex + 1).replaceAll("/", "--");
-  if (!collection || !slug) {
-    throw new Error(`invalid doc id: ${docId}`);
-  }
-  return { collection, slug };
-}
-var BatchRequest = class {
-  constructor(cmsClient, options) {
-    this.docIds = [];
-    this.dataSourceIds = [];
-    this.queries = [];
-    this.translationsIds = [];
-    this.cmsClient = cmsClient;
-    this.db = cmsClient.db;
-    this.options = options;
-  }
-  /**
-   * Adds a doc to the batch request.
-   */
-  addDoc(docId) {
-    this.docIds.push(docId);
-  }
-  /**
-   * Adds a data source to the batch request.
-   */
-  addDataSource(dataSourceId) {
-    this.dataSourceIds.push(dataSourceId);
-  }
-  /**
-   * Adds a collection-based query to the batch request.
-   */
-  addQuery(queryId, collectionId, queryOptions) {
-    this.queries.push({
-      queryId,
-      collectionId,
-      queryOptions
-    });
-  }
-  /**
-   * Adds a translation file to the request.
-   */
-  addTranslations(translationsId) {
-    this.translationsIds.push(translationsId);
-  }
-  /**
-   * Fetches data from the DB.
-   */
-  async fetch() {
-    const res = new BatchResponse();
-    const promises = [
-      this.fetchDocs(res),
-      this.fetchQueries(res),
-      this.fetchDataSources(res)
-    ];
-    if (!this.options.translate && this.translationsIds.length > 0) {
-      promises.push(this.fetchTranslations(res));
-    }
-    await Promise.all(promises);
-    if (this.translationsIds.length > 0) {
-      await this.fetchTranslations(res);
-    }
-    return res;
-  }
-  async fetchDocs(res) {
-    if (this.docIds.length === 0) {
-      return;
-    }
-    const docRefs = this.docIds.map((docId) => {
-      const [collectionId, slug] = docId.split("/");
-      return this.cmsClient.dbDocRef(collectionId, slug, {
-        mode: this.options.mode
-      });
-    });
-    const docs = await this.db.getAll(...docRefs);
-    this.docIds.forEach((docId, i) => {
-      const doc = docs[i];
-      if (!doc.exists) {
-        console.warn(`doc "${docId}" does not exist`);
-        return;
-      }
-      const docData = unmarshalData(doc.data());
-      res.docs[docId] = docData;
-      if (this.options.translate) {
-        this.addTranslations(docId);
-      }
-    });
-  }
-  async fetchQueries(res) {
-    if (this.queries.length === 0) {
-      return;
-    }
-    const mode = this.options.mode;
-    const handleQuery = async (queryItem) => {
-      const docsPath = this.cmsClient.dbCollectionDocsPath(
-        queryItem.collectionId,
-        { mode }
-      );
-      const queryOptions = queryItem.queryOptions || {};
-      let query = this.db.collection(docsPath);
-      if (queryOptions.limit) {
-        query = query.limit(queryOptions.limit);
-      }
-      if (queryOptions.offset) {
-        query = query.offset(queryOptions.offset);
-      }
-      if (queryOptions.orderBy) {
-        query = query.orderBy(
-          queryOptions.orderBy,
-          queryOptions.orderByDirection
-        );
-      }
-      if (queryOptions.query) {
-        query = queryOptions.query(query);
-      }
-      const results = await query.get();
-      const docs = [];
-      results.forEach((result) => {
-        const doc = unmarshalData(result.data());
-        docs.push(doc);
-      });
-      res.queries[queryItem.queryId] = docs;
-    };
-    await Promise.all(this.queries.map((queryItem) => handleQuery(queryItem)));
-  }
-  async fetchDataSources(res) {
-    if (this.dataSourceIds.length === 0) {
-      return;
-    }
-    const docRefs = this.dataSourceIds.map((dataSourceId) => {
-      return this.cmsClient.dbDataSourceDataRef(dataSourceId, {
-        mode: this.options.mode
-      });
-    });
-    const docs = await this.db.getAll(...docRefs);
-    this.dataSourceIds.forEach((dataSourceId, i) => {
-      const doc = docs[i];
-      if (!doc.exists) {
-        console.warn(`"data source "${dataSourceId}" does not exist`);
-        return;
-      }
-      res.dataSources[dataSourceId] = doc.data();
-    });
-  }
-  async fetchTranslations(res) {
-    if (this.translationsIds.length === 0) {
-      return;
-    }
-    const docRefs = this.translationsIds.map((translationsId) => {
-      return this.cmsClient.dbTranslationsRef(translationsId, {
-        mode: this.options.mode
-      });
-    });
-    const docs = await this.db.getAll(...docRefs);
-    this.translationsIds.forEach((translationsId, i) => {
-      const doc = docs[i];
-      if (!doc.exists) {
-        return;
-      }
-      res.translations[translationsId] = doc.data();
-    });
-  }
-};
-var BatchResponse = class {
-  constructor() {
-    this.docs = {};
-    this.queries = {};
-    this.dataSources = {};
-    this.translations = {};
-  }
-  /**
-   * Returns a map of translations for a given locale or locale fallbacks.
-   *
-   * The input is either a single locale (e.g. "de") or an array of locales
-   * representing the fallback tree, e.g. ["en-CA", "en-GB", "en"].
-   *
-   * TODO(stevenle): support the locale fallback tree.
-   *
-   * The returned value is a flat map of source string to translated string,
-   * e.g.:
-   * {"<source>": "<translation>"}
-   */
-  getTranslations(locale) {
-    const translationsMap = this.getTranslationsMap();
-    const translations = translationsForLocale(translationsMap, locale);
-    return translations;
-  }
-  /**
-   * Merges the strings from all translations files retrieved in the request.
-   * The returned value is a map of string to translations, e.g.:
-   *
-   * {"<hash>": {"source": "<source>", "<locale>": "<translation>"}}
-   */
-  getTranslationsMap() {
-    const translationsDocs = Object.values(this.translations).reverse();
-    const translationsMap = {};
-    for (const translationsDoc of translationsDocs) {
-      const strings = translationsDoc.strings || {};
-      for (const hash in strings) {
-        const translations = strings[hash];
-        translationsMap[hash] ??= { source: translations.source };
-        for (const locale in translations) {
-          if (locale !== "source" && translations[locale]) {
-            translationsMap[hash][locale] = translations[locale];
-          }
-        }
-      }
-    }
-    return translationsMap;
-  }
-};
-
-// core/versions.ts
-import path from "path";
-import { Timestamp as Timestamp3 } from "firebase-admin/firestore";
-import glob from "tiny-glob";
-var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
-var VersionsService = class {
-  constructor(rootConfig) {
-    this.rootConfig = rootConfig;
-    const cmsPlugin = getCmsPlugin(rootConfig);
-    const cmsPluginOptions = cmsPlugin.getConfig();
-    const projectId = cmsPluginOptions.id || "default";
-    this.projectId = projectId;
-    this.db = cmsPlugin.getFirestore();
-  }
-  /**
-   * Saves a version of all documents that have been edited since the last run.
-   */
-  async saveVersions() {
-    const lastRun = await this.getLastRun();
-    const lastRunWithOffset = lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;
-    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);
-    const now = Timestamp3.now().toMillis();
-    const versions = changedDocs.filter((doc) => {
-      const modifiedAt = doc.sys.modifiedAt.toMillis();
-      return modifiedAt <= now - DOCUMENT_SAVE_OFFSET;
-    });
-    if (versions.length > 0) {
-      this.saveVersionsToFirestore(versions);
-    }
-    this.saveLastRun(now);
-  }
-  async saveVersionsToFirestore(versions) {
-    const batch = this.db.batch();
-    versions.forEach((version) => {
-      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {
-        return;
-      }
-      const modifiedAtMillis = version.sys.modifiedAt.toMillis();
-      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;
-      console.log(versionPath);
-      const versionRef = this.db.doc(versionPath);
-      batch.set(versionRef, version);
-    });
-    await batch.commit();
-    console.log(`versions: saved ${versions.length} versions`);
-  }
-  /**
-   * Returns the last time (in millis) saveVersions() was run, or 0 if has
-   * never been run.
-   */
-  async getLastRun() {
-    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
-    const projectDoc = await projectDocRef.get();
-    if (projectDoc.exists) {
-      const data = projectDoc.data() || {};
-      const ts = data.versionsLastRun;
-      if (ts) {
-        return ts.toMillis();
-      }
-    }
-    return 0;
-  }
-  /**
-   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
-   */
-  async saveLastRun(millis) {
-    const ts = Timestamp3.fromMillis(millis);
-    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
-    await projectDocRef.set({ versionsLastRun: ts }, { merge: true });
-  }
-  /**
-   * Returns a list of all docs that were edited after a certain time.
-   */
-  async getDocsModifiedAfter(millis) {
-    const ts = Timestamp3.fromMillis(millis);
-    const results = [];
-    const collectionIds = await this.listCollections();
-    for (const collectionId of collectionIds) {
-      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const query = this.db.collection(collectionPath).where("sys.modifiedAt", ">=", ts);
-      const querySnapshot = await query.get();
-      querySnapshot.forEach((doc) => {
-        results.push(doc.data());
-      });
-    }
-    return results;
-  }
-  /**
-   * Returns a list of collection ids for the Root project.
-   */
-  async listCollections() {
-    const collectionIds = [];
-    const collectionFileNames = await glob("*.schema.ts", {
-      cwd: path.join(this.rootConfig.rootDir, "collections")
-    });
-    collectionFileNames.forEach((filename) => {
-      collectionIds.push(filename.slice(0, -10));
-    });
-    return collectionIds;
-  }
-};
-
-// core/cron.ts
-async function runCronJobs(rootConfig) {
-  await Promise.all([
-    runCronJob("publishScheduledDocs", runPublishScheduledDocs, rootConfig),
-    runCronJob("saveVersions", runSaveVersions, rootConfig)
-  ]);
-}
-async function runCronJob(name, fn, ...args) {
-  try {
-    await fn(...args);
-  } catch (err) {
-    console.log(`cron failed: ${name}`);
-    console.error(String(err.stack || err));
-    throw err;
-  }
-}
-async function runPublishScheduledDocs(rootConfig) {
-  const cmsClient = new RootCMSClient(rootConfig);
-  await cmsClient.publishScheduledDocs();
-  await cmsClient.publishScheduledReleases();
-}
-async function runSaveVersions(rootConfig) {
-  const service = new VersionsService(rootConfig);
-  await service.saveVersions();
-}
+  runCronJobs
+} from "./chunk-RIJF2AHU.js";
+import "./chunk-NUUABQRN.js";
+import "./chunk-MLKGABMK.js";
 
 // core/functions.ts
+import path from "path";
+import { loadBundledConfig } from "@blinkk/root/node";
+import { onSchedule } from "firebase-functions/v2/scheduler";
 function cron(options) {
-  const rootDir = path2.resolve(options?.rootDir || process.cwd());
+  const rootDir = path.resolve(options?.rootDir || process.cwd());
   const scheduleOptions = {
     schedule: "every 1 mins",
     ...options?.scheduleOptions