configre 2.1.2 → 2.1.4

package/README.md

@@ -124,7 +124,24 @@ const cfg = Configre(configPath);
 
 Secrets activate automatically when the base configuration or selected profile has a corresponding `.secret.cjs` file, or when `secrets.enc.json` already exists. No options are needed. Loading remains synchronous, and your application reads the result through ordinary properties such as `cfg.api.key`.
 
-> The demo reports `API key configured:` without printing the key. Avoid logging `cfg` in your application: it contains the decrypted secrets.
+> The demo reports `API key configured:` without printing the key. Avoid logging `cfg` in your application: it contains the decrypted secrets. Use `cfg.print()` to log configuration with secret fields omitted.
+
+```javascript
+const cfg = Configre(configPath);
+cfg.print();
+```
+
+`print()` calls Configre's `log.debug`; enable its output with `DEBUG=Configre:*`.
+It omits fields supplied by the base and selected profile's `.secret.cjs` files,
+including when loaded from the encrypted file. Public siblings in nested objects
+remain visible; arrays supplied by secrets are omitted entirely. It does not
+modify the configuration or log automatically on load. `cfg.print()` logs its
+current values, including changes made after loading. The method is non-enumerable
+and does not appear in `Object.keys(cfg)`, object spreads or JSON output.
+`new Configre(configPath).print()` is also supported. If your configuration already
+has a field named `print`, that value is preserved; use the constructor API to print it.
+Sensitivity is determined by secret-file fields, not by names such as `password`
+or `token`: keep sensitive values in `.secret.cjs` files, not in public settings.
 
 ### 1. Start the demo on the administrator machine
 

package/demo/secrets/demo.js

@@ -3,6 +3,7 @@ import { join } from "node:path";
 
 const configPath = join(import.meta.dirname, "config");
 const cfg = Configre(configPath);
+cfg.print();
 console.info("API key configured:", Boolean(cfg.api.key));
 console.info(`Set api.key in ${join(configPath, "index.secret.cjs")} and run this demo again.`);
 console.info(`New servers automatically publish their public key in ${join(configPath, "recipients")}. Pull and rerun here to authorize them.`);

package/index.js

@@ -9,6 +9,28 @@ import loadSecrets from "./secrets/index.js";
 const requireConfig = createRequire(import.meta.url);
 const log = lemonlog("Configre");
 
+function omitSecrets(settings, secrets) {
+    for (const [key, value] of Object.entries(secrets)) {
+        if (!Object.hasOwn(settings, key)) continue;
+        const current = settings[key];
+        if (value !== null && typeof value === "object" && !Array.isArray(value) &&
+            current !== null && typeof current === "object" && !Array.isArray(current)) {
+            omitSecrets(current, value);
+            if (Object.keys(current).length === 0) delete settings[key];
+        } else {
+            delete settings[key];
+        }
+    }
+}
+
+function printSettings(settings, secretSettings) {
+    const output = merge({}, settings);
+    for (const secrets of secretSettings) {
+        omitSecrets(output, secrets);
+    }
+    log.debug(output);
+}
+
 class ConfigreClass {
     constructor(pathOrDir) {
         if (typeof pathOrDir !== "string" || pathOrDir.length === 0) {
@@ -83,6 +105,10 @@ class ConfigreClass {
     get() {
         return merge({}, this.defaultSettings, this.profileSettings, ...this.secretSettings);
     }
+
+    print() {
+        printSettings(this.get(), this.secretSettings);
+    }
 }
 
 // Wrapper function to support both constructor and function usage
@@ -90,7 +116,14 @@ function Configre(path) {
     if (this instanceof Configre) {
         return new ConfigreClass(path);
     } else {
-        return new ConfigreClass(path).get();
+        const config = new ConfigreClass(path);
+        const settings = config.get();
+        if (!Object.hasOwn(settings, "print")) {
+            Object.defineProperty(settings, "print", {
+                value: () => printSettings(settings, config.secretSettings)
+            });
+        }
+        return settings;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configre",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "description": "🔧 Effortlessly Tailor Your Settings",
   "type": "module",
   "engines": {

package/test/secrets.test.js

@@ -80,6 +80,105 @@ function consumerCopy(f, name) {
     return { config };
 }
 
+test("print logs public configuration without creating secret artifacts", t => {
+    const f = fixture(t, { seed: false });
+    const calls = [];
+    t.mock.method(Object.getPrototypeOf(log), "debug", (...args) => calls.push(args));
+    const config = new Configre(f.config);
+
+    assert.equal(calls.length, 0);
+    config.print();
+    assert.deepEqual(calls, [[config.get()]]);
+    assert.equal(fs.existsSync(f.homes[0]), false);
+});
+
+test("function results expose print without changing enumerable data and log current settings", t => {
+    const f = fixture(t, { seed: false });
+    const calls = [];
+    t.mock.method(Object.getPrototypeOf(log), "debug", (...args) => calls.push(args));
+    const cfg = Configre(f.config);
+    const expected = new Configre(f.config).get();
+
+    assert.equal(typeof cfg.print, "function");
+    assert.deepEqual(Object.keys(cfg), Object.keys(expected));
+    assert.deepEqual({ ...cfg }, expected);
+    assert.equal(JSON.stringify(cfg), JSON.stringify(expected));
+    cfg.api.host = "updated";
+    cfg.print();
+    assert.deepEqual(calls, [[{ ...expected, api: { key: "", host: "updated" } }]]);
+    assert.equal(cfg.api.host, "updated");
+});
+
+test("a public print field remains configuration data", t => {
+    const f = fixture(t, { seed: false });
+    fs.writeFileSync(path.join(f.config, "index.cjs"), 'module.exports = { print: false };');
+    assert.equal(Configre(f.config).print, false);
+    const calls = [];
+    t.mock.method(Object.getPrototypeOf(log), "debug", (...args) => calls.push(args));
+    new Configre(f.config).print();
+    assert.equal(calls[0][0].print, false);
+});
+
+test("print omits local and encrypted secret fields without changing effective settings", t => {
+    const f = fixture(t);
+    const calls = [];
+    t.mock.method(Object.getPrototypeOf(log), "debug", (...args) => calls.push(args));
+    writeSettings(f, {
+        api: { key: sentinel },
+        list: [sentinel],
+        privateGroup: { value: sentinel },
+        optional: null,
+        empty: "",
+        enabled: false,
+        count: 0
+    });
+    fs.writeFileSync(path.join(f.config, "testhost.secret.cjs"),
+        `module.exports = { api: { other: ${JSON.stringify(sentinel)} }, privateGroup: "public-looking" };`);
+
+    load(f);
+    for (const source of [f, consumerCopy(f, "debug-consumer")]) {
+        const config = new Configre(source.config);
+        const before = config.get();
+        const secretsBefore = structuredClone(config.secretSettings);
+        config.print();
+
+        assert.deepEqual(calls.at(-1), [{ api: { host: "profile" } }]);
+        assert.equal(JSON.stringify(calls).includes(sentinel), false);
+        assert.deepEqual(config.get(), before);
+        assert.deepEqual(config.secretSettings, secretsBefore);
+        assert.equal(before.api.key, sentinel);
+        assert.equal(before.list[0], sentinel);
+        assert.equal(before.list[1], 2);
+        const cfg = Configre(source.config);
+        cfg.api.key = sentinel + "-updated";
+        cfg.api.host = "updated";
+        cfg.print();
+        assert.deepEqual(calls.at(-1), [{ api: { host: "updated" } }]);
+        assert.equal(JSON.stringify(calls).includes(sentinel), false);
+        assert.equal(cfg.api.key, sentinel + "-updated");
+    }
+    const result = spawnSync(process.execPath, ["-e", `
+        const os = require('node:os');
+        os.homedir = () => process.env.CONFIGRE_TEST_HOME;
+        const Configre = require(process.env.CONFIGRE_TEST_MODULE);
+        Configre(process.env.CONFIGRE_TEST_PATH).print();
+    `, "--", "--config=testhost"], {
+        encoding: "utf8",
+        env: {
+            ...process.env, DEBUG: "Configre:*",
+            CONFIGRE_TEST_HOME: f.homes[0],
+            CONFIGRE_TEST_MODULE: path.join(import.meta.dirname, "..", "index.js"),
+            CONFIGRE_TEST_PATH: path.join(f.root, "debug-consumer")
+        }
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = result.stdout + result.stderr;
+    assert.match(output, /Configre:debug/);
+    assert.match(output, /host: 'profile'/);
+    assert.equal(output.includes(sentinel), false);
+    assert.equal(output.includes("privateGroup"), false);
+});
+
 function git(directory, args) {
     const result = spawnSync("git", ["-C", directory, ...args], { encoding: "utf8" });
     assert.equal(result.status, 0, result.stderr);