@blinkk/root-cms 3.0.1-beta.3 → 3.0.1-beta.4

package/dist/app.js

@@ -1,8 +1,9 @@
 import {
   getServerVersion,
   serializeAiConfig
-} from "./chunk-NXEXOHBD.js";
-import "./chunk-CRK7N6RR.js";
+} from "./chunk-MVS2NLZM.js";
+import "./chunk-C245C557.js";
+import "./chunk-2BSW7SIH.js";
 import {
   getCollectionSchema,
   getProjectSchemas

package/dist/{chunk-F4SODS5S.js → chunk-2BSW7SIH.js}

@@ -1,7 +1,3 @@
-import {
-  validateFields
-} from "./chunk-CRK7N6RR.js";
-
 // core/client.ts
 import crypto from "crypto";
 import {
@@ -362,6 +358,301 @@ function buildTranslationsLocaleDocDbPath(options) {
   ).replace("{mode}", options.mode).replace("{id}", normalizeSlug(options.id)).replace("{locale}", options.locale);
 }
 
+// core/validation.ts
+function validateFields(fieldsData, schema) {
+  if (fieldsData === null || fieldsData === void 0) {
+    return [];
+  }
+  if (typeof fieldsData !== "object" || Array.isArray(fieldsData)) {
+    return [
+      {
+        path: "",
+        message: "Expected object for fields data",
+        expected: "object",
+        received: getType(fieldsData)
+      }
+    ];
+  }
+  const errors = [];
+  for (const field of schema.fields) {
+    if (!field.id) {
+      continue;
+    }
+    if (!(field.id in fieldsData)) {
+      continue;
+    }
+    const value = fieldsData[field.id];
+    errors.push(...validateValue(value, field, field.id));
+  }
+  return errors;
+}
+function validateValue(value, field, path) {
+  if (value === void 0) {
+    return [];
+  }
+  switch (field.type) {
+    case "string":
+    case "select":
+      if (typeof value !== "string") {
+        return [createError(path, "string", value)];
+      }
+      return [];
+    case "number":
+      if (typeof value !== "number") {
+        return [createError(path, "number", value)];
+      }
+      if (isNaN(value)) {
+        return [createError(path, "number", value)];
+      }
+      return [];
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return [createError(path, "boolean", value)];
+      }
+      return [];
+    case "date":
+    case "datetime": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      const seconds = value.seconds;
+      const nanoseconds = value.nanoseconds;
+      if (seconds === void 0) {
+        errors.push({
+          path: `${path}.seconds`,
+          message: "Required",
+          expected: "number",
+          received: "undefined"
+        });
+      } else if (typeof seconds !== "number") {
+        errors.push(createError(`${path}.seconds`, "number", seconds));
+      }
+      if (nanoseconds === void 0) {
+        errors.push({
+          path: `${path}.nanoseconds`,
+          message: "Required",
+          expected: "number",
+          received: "undefined"
+        });
+      } else if (typeof nanoseconds !== "number") {
+        errors.push(createError(`${path}.nanoseconds`, "number", nanoseconds));
+      }
+      return errors;
+    }
+    case "multiselect":
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      return value.flatMap((item, index) => {
+        if (typeof item !== "string") {
+          return [createError(`${path}.${index}`, "string", item)];
+        }
+        return [];
+      });
+    case "image":
+    case "file": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      if (value.src === void 0) {
+        errors.push({
+          path: `${path}.src`,
+          message: "Required",
+          expected: "string",
+          received: "undefined"
+        });
+      } else if (typeof value.src !== "string") {
+        errors.push(createError(`${path}.src`, "string", value.src));
+      }
+      if (value.alt !== void 0 && typeof value.alt !== "string") {
+        errors.push(createError(`${path}.alt`, "string", value.alt));
+      }
+      return errors;
+    }
+    case "object": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const objectField = field;
+      const errors = [];
+      for (const nestedField of objectField.fields) {
+        if (!nestedField.id || !(nestedField.id in value)) {
+          continue;
+        }
+        errors.push(
+          ...validateValue(
+            value[nestedField.id],
+            nestedField,
+            `${path}.${nestedField.id}`
+          )
+        );
+      }
+      return errors;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      const arrayField = field;
+      const itemField = arrayField.of;
+      return value.flatMap((item, index) => {
+        return validateValue(item, itemField, `${path}.${index}`);
+      });
+    }
+    case "oneof": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const oneOfField = field;
+      const typeName = value._type;
+      const typeMap = /* @__PURE__ */ new Map();
+      const typeNames = [];
+      for (const type of oneOfField.types) {
+        if (typeof type === "string") {
+          typeNames.push(type);
+          continue;
+        }
+        typeMap.set(type.name, type);
+        typeNames.push(type.name);
+      }
+      if (!typeNames.includes(typeName)) {
+        const expectedStr = typeNames.map((t) => `'${t}'`).join(" | ");
+        return [
+          {
+            path: `${path}._type`,
+            message: `Invalid discriminator value. Expected ${expectedStr}`,
+            expected: "valid discriminator value",
+            received: typeName
+          }
+        ];
+      }
+      const matchedSchema = typeMap.get(typeName);
+      if (!matchedSchema) {
+        return [];
+      }
+      const errors = [];
+      for (const nestedField of matchedSchema.fields) {
+        if (!nestedField.id || !(nestedField.id in value)) {
+          continue;
+        }
+        errors.push(
+          ...validateValue(
+            value[nestedField.id],
+            nestedField,
+            `${path}.${nestedField.id}`
+          )
+        );
+      }
+      return errors;
+    }
+    case "richtext": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      if (value.blocks === void 0) {
+        errors.push({
+          path: `${path}.blocks`,
+          message: "Required",
+          expected: "array",
+          received: "undefined"
+        });
+      } else if (!Array.isArray(value.blocks)) {
+        errors.push(createError(`${path}.blocks`, "array", value.blocks));
+      } else {
+        value.blocks.forEach((block, index) => {
+          if (typeof block !== "object" || block === null) {
+            errors.push(
+              createError(`${path}.blocks.${index}`, "object", block)
+            );
+            return;
+          }
+          if (block.type === void 0) {
+            errors.push({
+              path: `${path}.blocks.${index}.type`,
+              message: "Required",
+              expected: "string",
+              received: "undefined"
+            });
+          } else if (typeof block.type !== "string") {
+            errors.push(
+              createError(`${path}.blocks.${index}.type`, "string", block.type)
+            );
+          }
+        });
+      }
+      return errors;
+    }
+    case "reference": {
+      if (typeof value !== "object" || Array.isArray(value)) {
+        return [createError(path, "object", value)];
+      }
+      const errors = [];
+      const requiredFields = ["id", "collection", "slug"];
+      for (const req of requiredFields) {
+        if (value[req] === void 0) {
+          errors.push({
+            path: `${path}.${req}`,
+            message: "Required",
+            expected: "string",
+            received: "undefined"
+          });
+        } else if (typeof value[req] !== "string") {
+          errors.push(createError(`${path}.${req}`, "string", value[req]));
+        }
+      }
+      return errors;
+    }
+    case "references": {
+      if (!Array.isArray(value)) {
+        return [createError(path, "array", value)];
+      }
+      return value.flatMap((item, index) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+          return [createError(`${path}.${index}`, "object", item)];
+        }
+        const errors = [];
+        const requiredFields = ["id", "collection", "slug"];
+        for (const req of requiredFields) {
+          if (item[req] === void 0) {
+            errors.push({
+              path: `${path}.${index}.${req}`,
+              message: "Required",
+              expected: "string",
+              received: "undefined"
+            });
+          } else if (typeof item[req] !== "string") {
+            errors.push(
+              createError(`${path}.${index}.${req}`, "string", item[req])
+            );
+          }
+        }
+        return errors;
+      });
+    }
+    default:
+      console.warn(`Unknown field type: ${field.type}`);
+      return [];
+  }
+}
+function getType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number" && Number.isNaN(value)) return "nan";
+  return typeof value;
+}
+function createError(path, expected, receivedValue) {
+  const received = getType(receivedValue);
+  return {
+    path,
+    message: `Expected ${expected}, received ${received}`,
+    expected,
+    received
+  };
+}
+
 // core/values.ts
 function setValueAtPath(obj, path, value) {
   const keys = path.split(".");

package/dist/chunk-BGTUWIV6.js

@@ -0,0 +1,187 @@
+import {
+  SearchIndexService
+} from "./chunk-C245C557.js";
+import {
+  RootCMSClient,
+  getCmsPlugin
+} from "./chunk-2BSW7SIH.js";
+
+// core/cron.ts
+import { Timestamp as Timestamp2 } from "firebase-admin/firestore";
+
+// core/versions.ts
+import fs from "fs";
+import path from "path";
+import { Timestamp } 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 = Timestamp.now().toMillis();
+    const versions = changedDocs.filter((doc) => {
+      const modifiedAt = doc.sys.modifiedAt.toMillis();
+      if (modifiedAt > now - DOCUMENT_SAVE_OFFSET) {
+        return false;
+      }
+      const publishedAt = doc.sys.publishedAt?.toMillis?.();
+      if (publishedAt && Math.abs(publishedAt - modifiedAt) < 5e3) {
+        return false;
+      }
+      return true;
+    });
+    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 = Timestamp.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 = Timestamp.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 collectionsDir = path.join(this.rootConfig.rootDir, "collections");
+    if (!fs.existsSync(collectionsDir)) {
+      return [];
+    }
+    const collectionIds = [];
+    const collectionFileNames = await glob("*.schema.ts", {
+      cwd: collectionsDir
+    });
+    collectionFileNames.forEach((filename) => {
+      collectionIds.push(filename.slice(0, -10));
+    });
+    return collectionIds;
+  }
+};
+
+// core/cron.ts
+var SEARCH_INDEX_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+async function runCronJobs(rootConfig, options = {}) {
+  await Promise.all([
+    runCronJob("publishScheduledDocs", runPublishScheduledDocs, rootConfig),
+    runCronJob(
+      "syncScheduledDataSources",
+      runSyncScheduledDataSources,
+      rootConfig
+    ),
+    runCronJob("saveVersions", runSaveVersions, rootConfig),
+    runCronJob(
+      "incrementalSearchIndex",
+      runIncrementalSearchIndex,
+      rootConfig,
+      options.loadSchema
+    )
+  ]);
+}
+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 runSyncScheduledDataSources(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.syncScheduledDataSources();
+}
+async function runSaveVersions(rootConfig) {
+  const service = new VersionsService(rootConfig);
+  await service.saveVersions();
+}
+async function runIncrementalSearchIndex(rootConfig, loadSchema) {
+  const service = new SearchIndexService(rootConfig, loadSchema);
+  const status = await service.getStatus();
+  if (status.lastRun !== null) {
+    const elapsed = Date.now() - status.lastRun;
+    if (elapsed < SEARCH_INDEX_MIN_INTERVAL_MS) {
+      return;
+    }
+    const hasChanges = await service.hasChangesSince(
+      Timestamp2.fromMillis(status.lastRun)
+    );
+    if (!hasChanges) {
+      return;
+    }
+  }
+  await service.rebuildIndex({ force: false });
+}
+
+export {
+  runCronJobs
+};