@plume-press/cli 0.5.0 → 0.7.0

package/dist/local.mjs

@@ -33315,13 +33315,6 @@ function named(value, path) {
   );
 }
 function defineSchema(schema2) {
-  return checkSchema(schema2);
-}
-function readStoredSchema(schema2, ignored = () => {
-}) {
-  return checkSchema(schema2, ignored);
-}
-function checkSchema(schema2, ignoredPreviewPath) {
   canonicalJson(schema2);
   assert2(object2(schema2), "expected object");
   allowedKeys(schema2, ["collections", "singletons"], "schema");
@@ -33455,16 +33448,11 @@ function checkSchema(schema2, ignoredPreviewPath) {
     entities.add(entityName);
     validateFields2(entity2.fields, entityName, false);
     if ("previewPath" in entity2)
-      try {
-        validatePreviewPath(
-          entityName,
-          entity2.previewPath,
-          isCollection ? entity2.fields : null
-        );
-      } catch (error62) {
-        if (!ignoredPreviewPath) throw error62;
-        ignoredPreviewPath(error62.message);
-      }
+      validatePreviewPath(
+        entityName,
+        entity2.previewPath,
+        isCollection ? entity2.fields : null
+      );
   }
   return schema2;
 }
@@ -33502,10 +33490,11 @@ function validatePreviewPath(entity2, path, fields) {
   );
 }
 async function schemaHash(schema2) {
-  readStoredSchema(schema2);
-  const bytes2 = new TextEncoder().encode(
-    canonicalJson(schema2)
-  );
+  defineSchema(schema2);
+  return hashSchemaJson(canonicalJson(schema2));
+}
+async function hashSchemaJson(json2) {
+  const bytes2 = new TextEncoder().encode(json2);
   const digest = await crypto.subtle.digest("SHA-256", bytes2);
   return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
@@ -33645,7 +33634,10 @@ function validateRecord(schema2, name, data, options2) {
   const entity2 = [...schema2.collections, ...schema2.singletons ?? []].find(
     (candidate) => candidate.name === name
   );
-  if (!entity2)
+  return validateRecordFields(entity2?.fields, name, data, options2);
+}
+function validateRecordFields(fields, name, data, options2) {
+  if (!fields)
     return [
       {
         path: "",
@@ -33666,7 +33658,7 @@ function validateRecord(schema2, name, data, options2) {
   }
   const issues = [];
   validateFields(
-    entity2.fields,
+    fields,
     data,
     "",
     options2.publication,
@@ -34222,23 +34214,6 @@ async function safePath(cwd, create2) {
     );
   return path;
 }
-function addTimestamps(db) {
-  const missing = () => !db.prepare("PRAGMA table_info(local_records)").all().some((column) => column.name === "created_at");
-  if (!missing() && !db.prepare(
-    "SELECT 1 FROM local_records WHERE created_at IS NULL OR updated_at IS NULL LIMIT 1"
-  ).get())
-    return;
-  transaction(db, () => {
-    if (missing()) {
-      db.exec("ALTER TABLE local_records ADD COLUMN created_at INTEGER");
-      db.exec("ALTER TABLE local_records ADD COLUMN updated_at INTEGER");
-    }
-    const now = Date.now();
-    db.prepare(
-      "UPDATE local_records SET created_at = coalesce(created_at, ?), updated_at = coalesce(updated_at, created_at, ?) WHERE created_at IS NULL OR updated_at IS NULL"
-    ).run(now, now);
-  });
-}
 function meta3(db) {
   return db.prepare("SELECT schema, revision FROM local_meta WHERE id = 1").get();
 }
@@ -34444,7 +34419,6 @@ async function open2(path, expected) {
     db.exec("PRAGMA busy_timeout = 5000");
     const stored = meta3(db);
     if (!stored) throw new Error("Local content database is not initialized.");
-    addTimestamps(db);
     let schema2 = defineSchema(JSON.parse(stored.schema));
     if (expected && canonicalJson(schema2) !== canonicalJson(expected))
       throw new Error(
@@ -34633,7 +34607,7 @@ async function openLocalStore(input2) {
         "CREATE TABLE local_meta (id INTEGER PRIMARY KEY CHECK(id = 1), schema TEXT NOT NULL, revision INTEGER NOT NULL)"
       );
       db.exec(
-        "CREATE TABLE local_records (collection TEXT NOT NULL, record_id TEXT NOT NULL, data TEXT NOT NULL, visibility TEXT NOT NULL CHECK(visibility IN ('draft', 'public')), created_at INTEGER, updated_at INTEGER, PRIMARY KEY(collection, record_id))"
+        "CREATE TABLE local_records (collection TEXT NOT NULL, record_id TEXT NOT NULL, data TEXT NOT NULL, visibility TEXT NOT NULL CHECK(visibility IN ('draft', 'public')), created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, PRIMARY KEY(collection, record_id))"
       );
       db.prepare(
         "INSERT INTO local_meta (id, schema, revision) VALUES (1, ?, 0)"

package/dist/schema.d.ts

@@ -187,11 +187,6 @@ export type FieldIssue = {
 export declare function canonicalJson(value: JsonValue): string;
 /** Schema configuration is data only. Executable validators/transforms are unsupported. */
 export declare function defineSchema<const S extends SchemaDefinition>(schema: S): S;
-/** A schema stored with content, which an older Plume accepted: checked like
- * `defineSchema`, except that a `previewPath` this version's grammar rejects is reported
- * to `ignored` and left inert (`resolvePreviewPath` gives it no path), so that content
- * stays readable. Defining or registering a schema stays strict. */
-export declare function readStoredSchema(schema: unknown, ignored?: (problem: string) => void): SchemaDefinition;
 /** A path on the Site's own website: one leading `/`, no backslash, whitespace or control
  * character, at most 2048 characters, and still a path of the same site once a URL parser
  * normalises it (`/./`, `..`), so no browser or parser reads it as another host. */
@@ -201,9 +196,17 @@ export declare function isLocalPath(path: unknown): path is string;
  * Item ID (even when a Field is named `id`), `{<field>}` that text or slug Field's value,
  * each trimmed and URL-encoded. The result is always an `isLocalPath`. */
 export declare function resolvePreviewPath(entity: Collection | Singleton, recordId: string, data: JsonValue | undefined): string | null;
-/** Hashes a schema as stored: a `previewPath` an older Plume accepted doesn't change or
- * block its identity (see `readStoredSchema`). */
+/** Hashes a valid schema using its canonical JSON representation. */
 export declare function schemaHash(schema: SchemaDefinition): Promise<string>;
+/** Owns an immutable schema snapshot for validating many records without rechecking
+ * the schema. Mutating the source cannot change the snapshot or its cached hash. */
+export declare function createSchemaValidator<const S extends SchemaDefinition>(source: S): {
+    schema: S;
+    hash: () => Promise<string>;
+    validateRecord: (name: string, data: unknown, options: {
+        publication: boolean;
+    }) => FieldIssue[];
+};
 /** Validates shape only; richText HTML requires sanitization at the write/render boundary.
  * Slug uniqueness, reference targets and media `accept` need the whole content and are
  * checked where it is available (save, preparation, local store). */

package/dist/schema.mjs

@@ -83,13 +83,6 @@ function named(value, path) {
   );
 }
 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");
@@ -223,16 +216,11 @@ function checkSchema(schema, ignoredPreviewPath) {
     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);
-      }
+      validatePreviewPath(
+        entityName,
+        entity.previewPath,
+        isCollection ? entity.fields : null
+      );
   }
   return schema;
 }
@@ -296,13 +284,36 @@ function resolvePreviewPath(entity, recordId, data) {
   return !missing && isLocalPath(path) ? path : null;
 }
 async function schemaHash(schema) {
-  readStoredSchema(schema);
-  const bytes = new TextEncoder().encode(
-    canonicalJson(schema)
-  );
+  defineSchema(schema);
+  return hashSchemaJson(canonicalJson(schema));
+}
+async function hashSchemaJson(json) {
+  const bytes = new TextEncoder().encode(json);
   const digest = await crypto.subtle.digest("SHA-256", bytes);
   return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
 }
+function createSchemaValidator(source) {
+  const json = canonicalJson(source);
+  const schema = defineSchema(JSON.parse(json));
+  const freeze = (value) => {
+    for (const child of Object.values(value))
+      if (child !== null && typeof child === "object") freeze(child);
+    Object.freeze(value);
+  };
+  freeze(schema);
+  const entities = [...schema.collections, ...schema.singletons ?? []];
+  let hash;
+  return {
+    schema,
+    hash: () => hash ??= hashSchemaJson(json),
+    validateRecord: (name, data, options2) => validateRecordFields(
+      entities.find((entity) => entity.name === name)?.fields,
+      name,
+      data,
+      options2
+    )
+  };
+}
 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)) {
@@ -439,7 +450,10 @@ function validateRecord(schema, name, data, options2) {
   const entity = [...schema.collections, ...schema.singletons ?? []].find(
     (candidate) => candidate.name === name
   );
-  if (!entity)
+  return validateRecordFields(entity?.fields, name, data, options2);
+}
+function validateRecordFields(fields, name, data, options2) {
+  if (!fields)
     return [
       {
         path: "",
@@ -460,7 +474,7 @@ function validateRecord(schema, name, data, options2) {
   }
   const issues = [];
   validateFields(
-    entity.fields,
+    fields,
     data,
     "",
     options2.publication,
@@ -570,11 +584,11 @@ function validDate(value) {
 }
 export {
   canonicalJson,
+  createSchemaValidator,
   defineSchema,
   dropMissingReferences,
   isLocalPath,
   mediaAccepted,
-  readStoredSchema,
   referenceIds,
   resolvePreviewPath,
   schemaHash,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plume-press/cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "The plume command: set up a website's Plume CMS and check its builds.",
   "homepage": "https://app.plume.press",
   "license": "MIT",
@@ -32,7 +32,8 @@
     "THIRD_PARTY_NOTICES.md"
   ],
   "dependencies": {
-    "jiti": "2.7.0"
+    "jiti": "2.7.0",
+    "yazl": "3.3.1"
   },
   "publishConfig": {
     "access": "public"