@blinkk/root-cms 3.0.1-alpha.1 → 3.0.1-beta.2

package/dist/{chunk-SNZ4S4IC.js → chunk-F4SODS5S.js}

@@ -1,3 +1,7 @@
+import {
+  validateFields
+} from "./chunk-CRK7N6RR.js";
+
 // core/client.ts
 import crypto from "crypto";
 import {
@@ -358,301 +362,6 @@ 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(".");
@@ -1501,10 +1210,41 @@ ${errorMessages}`);
     const docRef = this.db.doc(dbPath);
     const doc = await docRef.get();
     if (doc.exists) {
-      return doc.data();
+      const dataSource = doc.data();
+      if (dataSource.archivedAt) {
+        console.warn(
+          `warning: data source "${dataSourceId}" is archived` + (dataSource.archivedBy ? ` (archived by ${dataSource.archivedBy})` : "")
+        );
+      }
+      return dataSource;
     }
     return null;
   }
+  /**
+   * Archives a data source. Archived data sources cannot be synced or published.
+   */
+  async archiveDataSource(dataSourceId, options) {
+    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;
+    const docRef = this.db.doc(dbPath);
+    const archivedBy = options?.archivedBy || "root-cms-client";
+    await docRef.update({
+      archivedAt: Timestamp2.now(),
+      archivedBy
+    });
+    console.log(`archived data source: ${dataSourceId}`);
+  }
+  /**
+   * Unarchives a data source.
+   */
+  async unarchiveDataSource(dataSourceId) {
+    const dbPath = `Projects/${this.projectId}/DataSources/${dataSourceId}`;
+    const docRef = this.db.doc(dbPath);
+    await docRef.update({
+      archivedAt: FieldValue2.delete(),
+      archivedBy: FieldValue2.delete()
+    });
+    console.log(`unarchived data source: ${dataSourceId}`);
+  }
   /**
    * Syncs a data source to draft state.
    */
@@ -1513,6 +1253,9 @@ ${errorMessages}`);
     if (!dataSource) {
       throw new Error(`data source not found: ${dataSourceId}`);
     }
+    if (dataSource.archivedAt) {
+      throw new Error(`data source is archived: ${dataSourceId}`);
+    }
     const result = await this.fetchData(dataSource);
     const dataSourceDocRef = this.db.doc(
       `Projects/${this.projectId}/DataSources/${dataSourceId}`
@@ -1545,6 +1288,9 @@ ${errorMessages}`);
     if (!dataSource) {
       throw new Error(`data source not found: ${dataSourceId}`);
     }
+    if (dataSource.archivedAt) {
+      throw new Error(`data source is archived: ${dataSourceId}`);
+    }
     const dataSourceDocRef = this.db.doc(
       `Projects/${this.projectId}/DataSources/${dataSourceId}`
     );
@@ -1578,6 +1324,40 @@ ${errorMessages}`);
     console.log(`published data ${dataSourceId}`);
     console.log(`published by: ${publishedBy}`);
   }
+  /**
+   * Unpublishes a data source. Removes the `publishedAt`/`publishedBy`
+   * metadata from the DataSource doc and deletes the `Data/published` doc.
+   */
+  async unpublishDataSource(dataSourceId) {
+    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}/Data/draft`
+    );
+    const dataDocRefPublished = this.db.doc(
+      `Projects/${this.projectId}/DataSources/${dataSourceId}/Data/published`
+    );
+    const batch = this.db.batch();
+    batch.update(dataSourceDocRef, {
+      publishedAt: FieldValue2.delete(),
+      publishedBy: FieldValue2.delete()
+    });
+    const draftSnapshot = await dataDocRefDraft.get();
+    if (draftSnapshot.exists) {
+      batch.update(dataDocRefDraft, {
+        "dataSource.publishedAt": FieldValue2.delete(),
+        "dataSource.publishedBy": FieldValue2.delete()
+      });
+    }
+    batch.delete(dataDocRefPublished);
+    await batch.commit();
+    console.log(`unpublished data source: ${dataSourceId}`);
+  }
   async publishDataSources(dataSourceIds, options) {
     const publishedBy = options?.publishedBy || "root-cms-client";
     const batch = options?.batch || this.db.batch();
@@ -1586,6 +1366,9 @@ ${errorMessages}`);
       if (!dataSource) {
         throw new Error(`data source not found: ${id}`);
       }
+      if (dataSource.archivedAt) {
+        throw new Error(`data source is archived: ${id}`);
+      }
       const dataSourceDocRef = this.db.doc(
         `Projects/${this.projectId}/DataSources/${id}`
       );
@@ -1751,7 +1534,14 @@ ${errorMessages}`);
     const docRef = this.dbDataSourceDataRef(dataSourceId, { mode });
     const doc = await docRef.get();
     if (doc.exists) {
-      return doc.data();
+      const dataSourceData = doc.data();
+      if (dataSourceData.dataSource?.archivedAt) {
+        const archivedBy = dataSourceData.dataSource.archivedBy;
+        console.warn(
+          `warning: data source "${dataSourceId}" is archived` + (archivedBy ? ` (archived by ${archivedBy})` : "")
+        );
+      }
+      return dataSourceData;
     }
     return null;
   }

package/dist/{chunk-R4LKO3EZ.js → chunk-MAZA5B27.js}

@@ -55,10 +55,10 @@ function testValidCollectionId(id) {
 function isSchemaPattern(value) {
   return typeof value === "object" && value !== null && "_schemaPattern" in value && value._schemaPattern === true;
 }
-function buildSchemaNameMap() {
+function buildSchemaNameMap(schemaModules = SCHEMA_MODULES) {
   const nameMap = {};
-  for (const fileId in SCHEMA_MODULES) {
-    const module = SCHEMA_MODULES[fileId];
+  for (const fileId in schemaModules) {
+    const module = schemaModules[fileId];
     if (module.default && module.default.name) {
       nameMap[module.default.name] = module.default;
     }
@@ -69,16 +69,16 @@ function globToRegex(pattern) {
   const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/\{\{DOUBLE_STAR\}\}/g, ".*");
   return new RegExp(`^${regexStr}$`);
 }
-function resolveSchemaPattern(pattern) {
+function resolveSchemaPattern(pattern, schemaModules = SCHEMA_MODULES) {
   const regex = globToRegex(pattern.pattern);
   const excludeSet = new Set(pattern.exclude || []);
   const names = [];
   const schemas = {};
-  for (const fileId in SCHEMA_MODULES) {
+  for (const fileId in schemaModules) {
     if (!regex.test(fileId)) {
       continue;
     }
-    const module = SCHEMA_MODULES[fileId];
+    const module = schemaModules[fileId];
     if (!module.default || !module.default.name) {
       continue;
     }
@@ -86,28 +86,25 @@ function resolveSchemaPattern(pattern) {
     if (excludeSet.has(schemaName)) {
       continue;
     }
-    let schemaObj = module.default;
+    const schemaObj = structuredClone(module.default);
     if (pattern.omitFields && pattern.omitFields.length > 0) {
       const omitSet = new Set(pattern.omitFields);
-      schemaObj = {
-        ...schemaObj,
-        fields: schemaObj.fields.filter(
-          (f) => !omitSet.has(f.id || "")
-        )
-      };
+      schemaObj.fields = schemaObj.fields.filter(
+        (f) => !omitSet.has(f.id || "")
+      );
     }
     names.push(schemaName);
     schemas[schemaName] = schemaObj;
   }
   return { names, schemas };
 }
-function convertOneOfTypes(collection) {
+function convertOneOfTypes(collection, schemaModules = SCHEMA_MODULES) {
   const clone = structuredClone(collection);
   const types = clone.types || {};
-  const schemaNameMap = buildSchemaNameMap();
+  const schemaNameMap = buildSchemaNameMap(schemaModules);
   function handleOneOfField(field) {
     if (isSchemaPattern(field.types)) {
-      const resolved = resolveSchemaPattern(field.types);
+      const resolved = resolveSchemaPattern(field.types, schemaModules);
       for (const [name, schemaObj] of Object.entries(resolved.schemas)) {
         if (!types[name]) {
           types[name] = schemaObj;
@@ -124,7 +121,7 @@ function convertOneOfTypes(collection) {
       if (typeof sub === "string") {
         names.push(sub);
         if (!types[sub] && schemaNameMap[sub]) {
-          const resolvedSchema = schemaNameMap[sub];
+          const resolvedSchema = structuredClone(schemaNameMap[sub]);
           types[sub] = resolvedSchema;
           if (resolvedSchema.fields) {
             walk(resolvedSchema);
@@ -166,5 +163,6 @@ export {
   SCHEMA_MODULES,
   getProjectSchemas,
   resolveOneOfPatterns,
-  getCollectionSchema
+  getCollectionSchema,
+  convertOneOfTypes
 };