@plume-press/cli 0.0.0-stage → 0.4.0

package/dist/schema.mjs

@@ -0,0 +1,585 @@
+// packages/core/src/schema.ts
+var reserved = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var kinds = /* @__PURE__ */ new Set([
+  "text",
+  "richText",
+  "number",
+  "boolean",
+  "date",
+  "select",
+  "slug",
+  "link",
+  "image",
+  "file",
+  "list",
+  "reference"
+]);
+var options = {
+  text: ["multiline", "maxLength"],
+  date: ["time"],
+  slug: ["from"],
+  select: ["options", "multiple"],
+  reference: ["collection", "multiple"],
+  image: ["multiple", "accept"],
+  file: ["multiple", "accept"],
+  list: ["fields"]
+};
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+function canonicalJson(value) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const visit = (input) => {
+    if (input === null || typeof input === "string" || typeof input === "boolean")
+      return JSON.stringify(input);
+    if (typeof input === "number" && Number.isFinite(input))
+      return JSON.stringify(input);
+    if (typeof input !== "object" || input === null)
+      throw new Error("Expected a finite JSON value");
+    if (ancestors.has(input)) throw new Error("Cyclic JSON value");
+    ancestors.add(input);
+    try {
+      if (Array.isArray(input)) {
+        if (Reflect.ownKeys(input).length !== input.length + 1)
+          throw new Error("Sparse or extended array");
+        return `[${Array.from({ length: input.length }, (_, i) => {
+          const entry = Object.getOwnPropertyDescriptor(input, String(i));
+          if (!entry || !("value" in entry))
+            throw new Error("Invalid array entry");
+          return visit(entry.value);
+        }).join(",")}]`;
+      }
+      if (!object(input)) throw new Error("Expected plain JSON object");
+      const keys = Reflect.ownKeys(input);
+      if (keys.some((key) => typeof key !== "string" || reserved.has(key)))
+        throw new Error("Reserved JSON key");
+      return `{${keys.sort().map((key) => {
+        const entry = Object.getOwnPropertyDescriptor(input, key);
+        if (!entry?.enumerable || !("value" in entry))
+          throw new Error("Expected enumerable JSON data property");
+        return `${JSON.stringify(key)}:${visit(entry.value)}`;
+      }).join(",")}}`;
+    } finally {
+      ancestors.delete(input);
+    }
+  };
+  return visit(value);
+}
+function assert(condition, message) {
+  if (!condition) throw new Error(`Invalid Plume schema: ${message}`);
+}
+function allowedKeys(value, keys, path) {
+  assert(
+    Object.keys(value).every((key) => keys.includes(key)),
+    `${path}: unknown property`
+  );
+}
+function named(value, path) {
+  assert(
+    typeof value.name === "string" && /^[A-Za-z][A-Za-z0-9_]*$/.test(value.name) && !reserved.has(value.name),
+    `${path}: invalid name`
+  );
+  assert(
+    typeof value.label === "string" && value.label.trim().length > 0,
+    `${path}: label is required`
+  );
+}
+function defineSchema(schema) {
+  return checkSchema(schema);
+}
+function readStoredSchema(schema, ignored = () => {
+}) {
+  return checkSchema(schema, ignored);
+}
+function checkSchema(schema, ignoredPreviewPath) {
+  canonicalJson(schema);
+  assert(object(schema), "expected object");
+  allowedKeys(schema, ["collections", "singletons"], "schema");
+  assert(Array.isArray(schema.collections), "collections must be an array");
+  assert(
+    schema.singletons === void 0 || Array.isArray(schema.singletons),
+    "singletons must be an array"
+  );
+  const collectionNames = new Set(
+    schema.collections.map(
+      (collection) => object(collection) ? collection.name : void 0
+    )
+  );
+  const entities = /* @__PURE__ */ new Set();
+  const validateFields2 = (fields, path, inList) => {
+    assert(
+      Array.isArray(fields) && fields.length > 0,
+      `${path}: nonempty fields array required`
+    );
+    const names = /* @__PURE__ */ new Set();
+    for (const field of fields) {
+      assert(object(field), `${path}: invalid field`);
+      named(field, path);
+      const name = field.name;
+      assert(!names.has(name), `${path}: duplicate field ${name}`);
+      names.add(name);
+      assert(
+        typeof field.kind === "string" && kinds.has(field.kind),
+        `${path}.${name}: invalid kind`
+      );
+      const extra = options[field.kind] ?? [];
+      allowedKeys(
+        field,
+        ["name", "label", "kind", "required", "locked", "default", ...extra],
+        `${path}.${name}`
+      );
+      for (const flag of [
+        "required",
+        "locked",
+        "multiple",
+        "multiline",
+        "time"
+      ]) {
+        assert(
+          field[flag] === void 0 || typeof field[flag] === "boolean",
+          `${path}.${name}: ${flag} must be boolean`
+        );
+      }
+      if (field.kind === "select") {
+        assert(
+          Array.isArray(field.options) && field.options.length > 0 && field.options.every(
+            (option) => typeof option === "string" && option.trim() !== ""
+          ) && new Set(field.options).size === field.options.length,
+          `${path}.${name}: invalid options`
+        );
+      }
+      if (field.kind === "reference")
+        assert(
+          typeof field.collection === "string" && collectionNames.has(field.collection),
+          `${path}.${name}: unknown reference collection`
+        );
+      if (field.kind === "text")
+        assert(
+          field.maxLength === void 0 || Number.isSafeInteger(field.maxLength) && field.maxLength >= 1,
+          `${path}.${name}: maxLength must be a positive integer`
+        );
+      if (field.kind === "slug" && field.from !== void 0)
+        assert(
+          typeof field.from === "string" && field.from !== name && fields.some(
+            (sibling) => object(sibling) && sibling.name === field.from && sibling.kind === "text"
+          ),
+          `${path}.${name}: from must name a text field beside it`
+        );
+      if ((field.kind === "image" || field.kind === "file") && field.accept !== void 0) {
+        assert(
+          Array.isArray(field.accept) && field.accept.length > 0 && new Set(field.accept).size === field.accept.length && field.accept.every(
+            (entry) => typeof entry === "string" && /^(?:[a-z]+\/(?:\*|[a-z0-9][a-z0-9.+-]*)|\.[a-z0-9]+)$/.test(
+              entry
+            )
+          ),
+          `${path}.${name}: accept must list lowercase MIME types or .extensions`
+        );
+        const supported = Object.keys(mediaExtensions).filter(
+          (type) => field.kind === "file" || type.startsWith("image/")
+        );
+        assert(
+          field.accept.every(
+            (entry) => supported.some(
+              (type) => mediaAccepted([entry], { mediaType: type, filename: "" })
+            )
+          ),
+          `${path}.${name}: accept supports only ${[
+            ...supported,
+            ...supported.flatMap((type) => mediaExtensions[type] ?? [])
+          ].join(", ")} and matching type/* wildcards`
+        );
+      }
+      if (field.kind === "list") {
+        assert(!inList, `${path}.${name}: nested lists are unsupported`);
+        validateFields2(field.fields, `${path}.${name}`, true);
+      }
+      if ("default" in field) {
+        assert(
+          !["slug", "reference", "image", "file"].includes(field.kind),
+          `${path}.${name}: default is not supported for ${field.kind} fields`
+        );
+        const problems = [];
+        validateValue(
+          field,
+          field.default,
+          "default",
+          false,
+          (_path, _code, message) => problems.push(message)
+        );
+        assert(
+          field.default !== null && problems.length === 0,
+          `${path}.${name}: default must be a valid value`
+        );
+      }
+    }
+  };
+  for (const [entity, isCollection] of [
+    ...schema.collections.map((entity2) => [entity2, true]),
+    ...(schema.singletons ?? []).map((entity2) => [entity2, false])
+  ]) {
+    assert(object(entity), "invalid collection or singleton");
+    named(entity, "entity");
+    const entityName = entity.name;
+    allowedKeys(entity, ["name", "label", "fields", "previewPath"], entityName);
+    assert(!entities.has(entityName), `duplicate entity ${entityName}`);
+    entities.add(entityName);
+    validateFields2(entity.fields, entityName, false);
+    if ("previewPath" in entity)
+      try {
+        validatePreviewPath(
+          entityName,
+          entity.previewPath,
+          isCollection ? entity.fields : null
+        );
+      } catch (error) {
+        if (!ignoredPreviewPath) throw error;
+        ignoredPreviewPath(error.message);
+      }
+  }
+  return schema;
+}
+function isLocalPath(path) {
+  if (typeof path !== "string" || path.length > 2048 || !/^\/(?!\/)/.test(path) || /[\\\s\p{Cc}]/u.test(path))
+    return false;
+  const url = new URL(path, "https://site.invalid");
+  return url.host === "site.invalid" && !url.pathname.startsWith("//");
+}
+var placeholder = /\{([^{}]*)\}/g;
+function validatePreviewPath(entity, path, fields) {
+  assert(
+    isLocalPath(path),
+    `${entity}: previewPath must be a local path starting with /`
+  );
+  for (const [, name = ""] of path.matchAll(placeholder)) {
+    assert(
+      fields,
+      `${entity}: a singleton previewPath is a fixed path without {placeholders}`
+    );
+    if (name === "id") continue;
+    const field = fields.find((candidate) => candidate.name === name);
+    assert(
+      field,
+      `${entity}: previewPath placeholder {${name}} must be {id} or a field of ${entity}`
+    );
+    assert(
+      field.kind === "text" || field.kind === "slug",
+      `${entity}: previewPath placeholder {${name}} must name a text or slug field, not ${field.kind}`
+    );
+  }
+  assert(
+    !/[{}]/.test(path.replace(placeholder, "")),
+    `${entity}: previewPath has an unmatched { or }`
+  );
+}
+function resolvePreviewPath(entity, recordId, data) {
+  const template = entity.previewPath;
+  if (template === void 0) return null;
+  try {
+    validatePreviewPath(entity.name, template, entity.fields);
+  } catch {
+    return null;
+  }
+  let missing = false;
+  const path = template.replace(placeholder, (_, name) => {
+    const field = entity.fields.find((candidate) => candidate.name === name);
+    const raw = name === "id" ? recordId : field?.kind === "text" || field?.kind === "slug" ? object(data) && data[name] : void 0;
+    const value = typeof raw === "string" ? raw.trim() : "";
+    if (value === "" || value === "." || value === "..") {
+      missing = true;
+      return "";
+    }
+    try {
+      return encodeURIComponent(value);
+    } catch {
+      missing = true;
+      return "";
+    }
+  });
+  return !missing && isLocalPath(path) ? path : null;
+}
+async function schemaHash(schema) {
+  readStoredSchema(schema);
+  const bytes = new TextEncoder().encode(
+    canonicalJson(schema)
+  );
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+var unset = (field, record) => !Object.hasOwn(record, field.name) || record[field.name] === null && !field.required;
+function validateFields(fields, value, prefix, publication, report) {
+  if (!object(value)) {
+    report(prefix, "type", "Expected record object");
+    return;
+  }
+  for (const key of Object.keys(value))
+    if (!fields.some((field) => field.name === key))
+      report(
+        prefix ? `${prefix}.${key}` : key,
+        "unknown_field",
+        "Unknown field"
+      );
+  for (const field of fields) {
+    const path = prefix ? `${prefix}.${field.name}` : field.name;
+    if (unset(field, value)) {
+      if (publication && field.required)
+        report(path, "required", "Required field is missing");
+      continue;
+    }
+    const v = value[field.name];
+    if (publication && field.required && (v === "" || Array.isArray(v) && v.length === 0)) {
+      report(path, "required", "Required field is empty");
+      continue;
+    }
+    validateValue(field, v, path, publication, report);
+  }
+}
+function validateValue(field, v, path, publication, report) {
+  const typeError = (expected) => report(path, "type", `Expected ${expected}`);
+  const distinct = (expected, entry) => {
+    if (!Array.isArray(v)) return typeError(expected);
+    v.forEach((item, index) => {
+      entry(item, `${path}[${index}]`);
+    });
+    if (v.every((item) => typeof item === "string") && new Set(v).size !== v.length)
+      report(path, "format", "Choose each value only once");
+  };
+  switch (field.kind) {
+    case "number":
+      if (typeof v !== "number") typeError("number");
+      break;
+    case "boolean":
+      if (typeof v !== "boolean") typeError("boolean");
+      break;
+    case "text":
+      if (typeof v !== "string") typeError("string");
+      else if (field.maxLength !== void 0 && Array.from(v).length > field.maxLength)
+        report(path, "format", `Use at most ${field.maxLength} characters`);
+      break;
+    case "richText":
+      if (typeof v !== "string") typeError("string");
+      break;
+    case "slug":
+      if (typeof v !== "string") typeError("slug string");
+      else if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v))
+        report(path, "format", "Expected lowercase hyphen-separated slug");
+      break;
+    case "date":
+      if (typeof v !== "string") typeError("ISO date string");
+      else if (!validDate(v))
+        report(path, "format", "Expected valid ISO date or UTC timestamp");
+      else if (field.time === true && v.length === 10)
+        report(path, "format", "Expected a UTC date and time");
+      else if (field.time === false && v.length !== 10)
+        report(path, "format", "Expected a date without a time");
+      break;
+    case "select": {
+      const option = (item, itemPath) => {
+        if (typeof item !== "string")
+          report(itemPath, "type", "Expected option string");
+        else if (!field.options.includes(item))
+          report(itemPath, "format", "Unknown option");
+      };
+      if (field.multiple) distinct("option array", option);
+      else option(v, path);
+      break;
+    }
+    case "reference": {
+      const id = (item, itemPath) => {
+        if (typeof item !== "string")
+          report(itemPath, "type", "Expected record ID");
+        else if (item.trim() === "")
+          report(itemPath, "format", "Record ID cannot be empty");
+      };
+      if (field.multiple) distinct("record ID array", id);
+      else id(v, path);
+      break;
+    }
+    case "link":
+      if (!object(v) || typeof v.value !== "string" || typeof v.kind !== "string" || !["url", "email", "phone"].includes(v.kind) || Object.keys(v).some(
+        (key) => key !== "kind" && key !== "value" && key !== "newTab"
+      ) || v.newTab !== void 0 && typeof v.newTab !== "boolean")
+        typeError("link object");
+      else if (v.newTab === true && v.kind !== "url")
+        report(path, "format", "Only URL links can open in a new tab");
+      else {
+        const valid = v.kind === "email" ? /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v.value) : v.kind === "phone" ? /^\+?[0-9][0-9 ()-]{2,}$/.test(v.value) : validUrl(v.value);
+        if (!valid) report(path, "format", "Invalid link value");
+      }
+      break;
+    case "image":
+    case "file": {
+      const media = (entry, mediaPath) => {
+        if (!object(entry) || typeof entry.id !== "string" || entry.id.trim() === "" || entry.alt !== void 0 && typeof entry.alt !== "string" || Object.keys(entry).some((key) => key !== "id" && key !== "alt"))
+          report(mediaPath, "type", "Expected media reference { id, alt? }");
+      };
+      if (field.multiple) {
+        if (!Array.isArray(v)) typeError("media reference array");
+        else
+          v.forEach((entry, index) => {
+            media(entry, `${path}[${index}]`);
+          });
+      } else media(v, path);
+      break;
+    }
+    case "list":
+      if (!Array.isArray(v)) typeError("list of records");
+      else
+        v.forEach((entry, index) => {
+          validateFields(
+            field.fields,
+            entry,
+            `${path}[${index}]`,
+            publication,
+            report
+          );
+        });
+      break;
+  }
+}
+function validateRecord(schema, name, data, options2) {
+  defineSchema(schema);
+  const entity = [...schema.collections, ...schema.singletons ?? []].find(
+    (candidate) => candidate.name === name
+  );
+  if (!entity)
+    return [
+      {
+        path: "",
+        code: "unknown_collection",
+        message: `Unknown collection or singleton: ${name}`
+      }
+    ];
+  try {
+    canonicalJson(data);
+  } catch {
+    return [
+      {
+        path: "",
+        code: "invalid_json",
+        message: "Record must contain only plain, finite JSON values"
+      }
+    ];
+  }
+  const issues = [];
+  validateFields(
+    entity.fields,
+    data,
+    "",
+    options2.publication,
+    (path, code, message) => {
+      issues.push({ path, code, message });
+    }
+  );
+  return issues;
+}
+function stripNullFields(fields, data) {
+  if (!object(data)) return data;
+  const result = { ...data };
+  for (const field of fields) {
+    const value = result[field.name];
+    if (value === null && !field.required) delete result[field.name];
+    else if (field.kind === "list" && Array.isArray(value))
+      result[field.name] = value.map(
+        (row) => object(row) ? stripNullFields(field.fields, row) : row
+      );
+  }
+  return result;
+}
+function withNullFields(fields, data) {
+  const result = { ...data };
+  for (const field of fields) {
+    const value = result[field.name];
+    if (value === void 0) {
+      if (!field.required) result[field.name] = null;
+    } else if (field.kind === "list" && Array.isArray(value))
+      result[field.name] = value.map(
+        (row) => object(row) ? withNullFields(field.fields, row) : row
+      );
+  }
+  return result;
+}
+function referenceIds(value) {
+  if (typeof value === "string") return [value];
+  return Array.isArray(value) ? value.filter((id) => typeof id === "string") : [];
+}
+function dropMissingReferences(fields, data, exists) {
+  let changed = false;
+  const result = { ...data };
+  for (const field of fields) {
+    const value = result[field.name];
+    if (field.kind === "reference" && !field.required && value != null) {
+      const ids = referenceIds(value);
+      const kept = ids.filter((id) => exists(field.collection, id));
+      if (kept.length === ids.length) continue;
+      changed = true;
+      if (Array.isArray(value) && kept.length) result[field.name] = kept;
+      else delete result[field.name];
+    } else if (field.kind === "list" && Array.isArray(value)) {
+      const rows = value.map((row) => {
+        if (!object(row)) return row;
+        const resolved = dropMissingReferences(
+          field.fields,
+          row,
+          exists
+        );
+        if (resolved) changed = true;
+        return resolved ?? row;
+      });
+      if (changed) result[field.name] = rows;
+    }
+  }
+  return changed ? result : null;
+}
+function slugify(value) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+var mediaExtensions = {
+  "image/jpeg": [".jpg", ".jpeg"],
+  "image/png": [".png"],
+  "image/webp": [".webp"],
+  "image/gif": [".gif"],
+  "image/avif": [".avif"],
+  "application/pdf": [".pdf"]
+};
+function mediaAccepted(accept, asset) {
+  if (!accept) return true;
+  const type = asset.mediaType.toLowerCase();
+  const dot = asset.filename.lastIndexOf(".");
+  const extensions = /* @__PURE__ */ new Set([
+    ...mediaExtensions[type] ?? [],
+    ...dot > 0 ? [asset.filename.slice(dot).toLowerCase()] : []
+  ]);
+  return accept.some(
+    (entry) => entry.startsWith(".") ? extensions.has(entry) : entry.endsWith("/*") ? type.startsWith(entry.slice(0, -1)) : type === entry
+  );
+}
+function validUrl(value) {
+  if (/^(\/(?!\/)|#)/.test(value) && !/[\s\\]/.test(value)) return true;
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !/\s/.test(value);
+  } catch {
+    return false;
+  }
+}
+function validDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z)?$/.test(value))
+    return false;
+  const time = Date.parse(value);
+  if (!Number.isFinite(time)) return false;
+  const normalized = new Date(time).toISOString();
+  return value.length === 10 ? normalized.slice(0, 10) === value : normalized === (value.includes(".") ? value : value.replace("Z", ".000Z"));
+}
+export {
+  canonicalJson,
+  defineSchema,
+  dropMissingReferences,
+  isLocalPath,
+  mediaAccepted,
+  readStoredSchema,
+  referenceIds,
+  resolvePreviewPath,
+  schemaHash,
+  slugify,
+  stripNullFields,
+  validateRecord,
+  withNullFields
+};

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@plume-press/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "The plume command: set up a website's Plume CMS and check its builds.",
+  "homepage": "https://app.plume.press",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "bin": {
+    "plume": "dist/cli.mjs"
+  },
+  "exports": {
+    "./local": {
+      "types": "./dist/local.d.ts",
+      "default": "./dist/local.mjs"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "default": "./dist/schema.mjs"
+    }
+  },
+  "files": [
+    "dist/local.mjs",
+    "dist/local.d.ts",
+    "dist/cli.mjs",
+    "dist/schema.mjs",
+    "dist/schema.d.ts",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "dependencies": {
+    "jiti": "2.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}