funoteka 0.1.0

package/dist/api/log-file.js

@@ -0,0 +1,65 @@
+import { createWriteStream, openSync } from 'node:fs';
+/**
+ * Append this process's output to a file, or say why it cannot and carry on.
+ *
+ * **A log file that cannot be opened is not a reason to refuse to serve.** The
+ * failure is said on stderr — which is where it would have gone anyway — and the
+ * server starts without it. The opposite choice, refusing to serve music because
+ * a log path is mistyped, trades the whole product for a diagnostic about it.
+ *
+ * The file is opened *before* the streams are tapped, on purpose: `openSync`
+ * throws where a path has no directory, so the failure arrives here as a
+ * sentence rather than asynchronously as an unwritable stream nobody is
+ * listening to.
+ */
+export function logToFile(path) {
+    let stream;
+    try {
+        stream = createWriteStream(path, { fd: openSync(path, 'a') });
+    }
+    catch (err) {
+        process.stderr.write(`funoteka: no log file at ${path} (${err.message}) — carrying on without one\n`);
+        return () => { };
+    }
+    const teed = [tee(process.stdout, stream), tee(process.stderr, stream)];
+    const stop = () => {
+        while (teed.length > 0)
+            teed.pop()?.stop();
+        stream.end();
+    };
+    // A disk that filled up is the one failure left, and it arrives here rather
+    // than at a call site: the log stops, and a line about it goes to the original
+    // stderr — the tapped one would be writing into the stream that just failed.
+    stream.on('error', (err) => {
+        const original = process.stderr.write.bind(process.stderr);
+        stop();
+        original(`funoteka: the log file at ${path} stopped (${err.message})\n`);
+    });
+    return stop;
+}
+/**
+ * One stream tapped: what was written to it goes to the file as well.
+ *
+ * The return value of the original write is passed back untouched, because call
+ * sites and Node itself read it (back-pressure); the callback is passed to the
+ * original and *not* to the file, because it belongs to one write and a caller
+ * that wanted to know when its line reached a terminal has not asked to be told
+ * twice.
+ */
+function tee(out, stream) {
+    const original = out.write.bind(out);
+    out.write = ((chunk, encoding, callback) => {
+        try {
+            stream.write(chunk);
+        }
+        catch {
+            // The log is not worth a throw on the way to the thing being logged.
+        }
+        return original(chunk, encoding, callback);
+    });
+    return {
+        stop: () => {
+            out.write = original;
+        },
+    };
+}