@rr0/cms 0.3.63 → 0.3.64

package/dist/CMSGenerator.js

@@ -178,6 +178,12 @@ export class CMSGenerator {
                     : new HtAccessToNetlifyConfigReplaceCommand(this.options.siteBaseUrl, netlify.preambleFile)
             ],
             roots: [".htaccess"],
+            // The preamble is the output's OTHER half, and it is not walked as a root — so without this
+            // the incremental rule ("is .htaccess newer than the output?") never sees it change, and an
+            // edit to it produces a successful build that deploys the previous output. It happened: two
+            // dead redirect rules survived their own removal, and only a reading of the deployed file
+            // caught it.
+            alsoDerivedFrom: netlify.preambleFile ? [netlify.preambleFile] : [],
             getOutputPath: (_context) => netlify.outputPath
         };
         const contentRoots = this.options.contentRoots;

package/dist/RR0ContentStep.d.ts

@@ -8,6 +8,25 @@ export interface FileVisitor {
     visit(context: HtmlRR0Context, processFile: boolean): Promise<void>;
     contentStepEnd(): Promise<void>;
 }
+/**
+ * A content config whose output is derived from more than the file being walked.
+ *
+ * The incremental rule this step inherits is "process the file if it is newer than its own output",
+ * which is exact as long as the file IS the only input. It is not always: the Netlify redirects are
+ * generated from `.htaccess` AND from a preamble holding everything Apache's directives cannot say
+ * (see `CMSGenerator`'s `netlify.preambleFile`). Nothing declared that second half, so editing it
+ * alone changed nothing — the output stayed at whatever the last `.htaccess` change had produced,
+ * and the build reported success. That is the worst shape a staleness bug can take: silent, and
+ * visible only to whoever reads the deployed file.
+ *
+ * Naming the dependency here rather than always reprocessing keeps the incremental build
+ * incremental, and puts the statement where the config that needs it can be read.
+ */
+export interface ContentStepDependencies {
+    /** Paths, as the working directory sees them, that this config's output also derives from. */
+    alsoDerivedFrom?: string[];
+}
+export type RR0ContentStepConfig = ContentStepConfig & ContentStepDependencies;
 export interface RR0ContentStepOptions {
     contentConfigs: ContentStepConfig[];
     outputFunc: OutputFunc;
@@ -24,5 +43,15 @@ export declare class RR0ContentStep extends ContentStep<HtmlRR0Context> {
     protected processFile(context: HtmlRR0Context, filePath: string, contentsConfig: ContentStepConfig): Promise<string | undefined>;
     protected shouldProcessFile(context: HtmlRR0Context, contentsConfig: ContentStepConfig): Promise<boolean>;
     protected shouldProcessContent(context: HtmlRR0Context, contentsConfig: ContentStepConfig): Promise<boolean>;
+    /**
+     * Whether a file this config's output ALSO derives from is newer than that output — see
+     * `ContentStepDependencies`.
+     *
+     * A dependency that has gone missing counts as changed rather than as unchanged: an output built
+     * from something no longer there should be rebuilt, and the rebuild is where that failure gets
+     * reported (the preamble reader throws on a name it cannot find, deliberately). Answering "no"
+     * would keep serving the stale output and say nothing.
+     */
+    private otherInputHasChanged;
     protected postExecute(result: ContentStepResult): Promise<ContentStepResult>;
 }

package/dist/RR0ContentStep.js

@@ -1,3 +1,4 @@
+import fs from "fs";
 import { ContentStep } from "ssg-api";
 export class RR0ContentStep extends ContentStep {
     constructor(options, timeService) {
@@ -14,7 +15,8 @@ export class RR0ContentStep extends ContentStep {
     async shouldProcessFile(context, contentsConfig) {
         const fileHasChanged = await super.shouldProcessFile(context, contentsConfig);
         const fileIsForced = this.options.toProcess.has(context.file.name);
-        const processFile = this.options.force || fileIsForced || fileHasChanged;
+        const processFile = this.options.force || fileIsForced || fileHasChanged
+            || this.otherInputHasChanged(context, contentsConfig);
         if (processFile) {
             this.options.toProcess.add(context.file.name);
         }
@@ -34,6 +36,27 @@ export class RR0ContentStep extends ContentStep {
         }
         return should;
     }
+    /**
+     * Whether a file this config's output ALSO derives from is newer than that output — see
+     * `ContentStepDependencies`.
+     *
+     * A dependency that has gone missing counts as changed rather than as unchanged: an output built
+     * from something no longer there should be rebuilt, and the rebuild is where that failure gets
+     * reported (the preamble reader throws on a name it cannot find, deliberately). Answering "no"
+     * would keep serving the stale output and say nothing.
+     */
+    otherInputHasChanged(context, contentsConfig) {
+        const dependencies = contentsConfig.alsoDerivedFrom;
+        if (!(dependencies === null || dependencies === void 0 ? void 0 : dependencies.length)) {
+            return false;
+        }
+        const outputPath = contentsConfig.getOutputPath(context);
+        if (!fs.existsSync(outputPath)) {
+            return true;
+        }
+        const outputTime = fs.statSync(outputPath).mtime.getTime();
+        return dependencies.some(dependency => !fs.existsSync(dependency) || fs.statSync(dependency).mtime.getTime() > outputTime);
+    }
     async postExecute(result) {
         await super.postExecute(result);
         for (const fileVisitor of this.options.fileVisitors) {

package/dist/RR0ContentStep.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/RR0ContentStep.test.js

@@ -0,0 +1,78 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { RR0ContentStep } from "./RR0ContentStep.js";
+/**
+ * The incremental rule, and the second input it used not to know about.
+ *
+ * Reaches `shouldProcessFile` directly rather than running a whole generation: what is under test
+ * is one decision — "is this output stale?" — and the file dates that answer it.
+ */
+describe("RR0ContentStep incremental rule", () => {
+    let dir;
+    let source;
+    let preamble;
+    let output;
+    const at = (file, minutesAgo) => {
+        const when = new Date(Date.now() - minutesAgo * 60000);
+        fs.utimesSync(file, when, when);
+    };
+    const contextFor = (file) => ({
+        file: { name: file, lastModified: fs.statSync(file).mtime }
+    });
+    const stepFor = (config) => {
+        const step = new RR0ContentStep({
+            contentConfigs: [config], outputFunc: async () => undefined, force: false,
+            name: "test", toProcess: new Set()
+        }, { setContextFromFile: () => undefined });
+        return step;
+    };
+    const shouldProcess = (step, config) => step.shouldProcessFile(contextFor(source), config);
+    const configWith = (alsoDerivedFrom) => ({
+        roots: [source], replacements: [], alsoDerivedFrom, getOutputPath: (_context) => output
+    });
+    beforeEach(() => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), "rr0-content-step-"));
+        source = path.join(dir, ".htaccess");
+        preamble = path.join(dir, "_redirects.head");
+        output = path.join(dir, "_redirects");
+        fs.writeFileSync(source, "Redirect /a /b\n");
+        fs.writeFileSync(preamble, "# trunk\n");
+        fs.writeFileSync(output, "# trunk\n/a /b\n");
+        // An output built after both its inputs: nothing to do.
+        at(source, 10);
+        at(preamble, 10);
+        at(output, 5);
+    });
+    afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
+    test("leaves an output alone while neither of its inputs has moved", async () => {
+        const config = configWith([preamble]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(false);
+    });
+    test("rebuilds when the walked file changes, as it always did", async () => {
+        at(source, 0);
+        const config = configWith([preamble]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(true);
+    });
+    test("rebuilds when only the PREAMBLE changes — the bug this exists for", async () => {
+        at(preamble, 0);
+        const config = configWith([preamble]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(true);
+    });
+    test("without the declaration, a preamble change goes on being missed", async () => {
+        at(preamble, 0);
+        const config = configWith([]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(false);
+    });
+    test("a dependency that has gone missing counts as changed, not as unchanged", async () => {
+        fs.rmSync(preamble);
+        const config = configWith([preamble]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(true);
+    });
+    test("no output yet means build it, whatever the dates say", async () => {
+        fs.rmSync(output);
+        const config = configWith([preamble]);
+        expect(await shouldProcess(stepFor(config), config)).toBe(true);
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@rr0/cms",
   "type": "module",
   "author": "Jérôme Beau <rr0@rr0.org> (https://rr0.org)",
-  "version": "0.3.63",
+  "version": "0.3.64",
   "description": "RR0 Content Management System (CMS)",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",