@brianbuie/node-kit 0.9.0 → 0.9.2

package/dist/File.js

@@ -1,185 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { Readable } from 'node:stream';
-import { finished } from 'node:stream/promises';
-import { writeToStream, parseStream } from 'fast-csv';
-import { snapshot } from './snapshot.js';
-/**
- * WARNING: API will change!
- */
-export class File {
-    path;
-    constructor(filepath) {
-        this.path = filepath;
-    }
-    get exists() {
-        return fs.existsSync(this.path);
-    }
-    delete() {
-        fs.rmSync(this.path, { force: true });
-    }
-    read() {
-        return this.exists ? fs.readFileSync(this.path, 'utf8') : undefined;
-    }
-    /**
-     * @returns lines as strings, removes trailing '\n'
-     */
-    lines() {
-        const contents = (this.read() || '').split('\n');
-        return contents.slice(0, contents.length - 1);
-    }
-    get readStream() {
-        return this.exists ? fs.createReadStream(this.path) : Readable.from([]);
-    }
-    get writeStream() {
-        fs.mkdirSync(path.parse(this.path).dir, { recursive: true });
-        return fs.createWriteStream(this.path);
-    }
-    write(contents) {
-        fs.mkdirSync(path.parse(this.path).dir, { recursive: true });
-        if (typeof contents === 'string')
-            return fs.writeFileSync(this.path, contents);
-        if (contents instanceof ReadableStream)
-            return finished(Readable.from(contents).pipe(this.writeStream));
-        throw new Error(`Invalid content type: ${typeof contents}`);
-    }
-    /**
-     * creates file if it doesn't exist, appends string or array of strings as new lines.
-     * File always ends with '\n', so contents don't need to be read before appending
-     */
-    append(lines) {
-        if (!this.exists)
-            this.write('');
-        const contents = Array.isArray(lines) ? lines.join('\n') : lines;
-        fs.appendFileSync(this.path, contents + '\n');
-    }
-    static get FileType() {
-        return FileType;
-    }
-    json(contents) {
-        return new FileTypeJson(this.path, contents);
-    }
-    static get json() {
-        return FileTypeJson;
-    }
-    ndjson(lines) {
-        return new FileTypeNdjson(this.path, lines);
-    }
-    static get ndjson() {
-        return FileTypeNdjson;
-    }
-    async csv(rows, keys) {
-        const csvFile = new FileTypeCsv(this.path);
-        if (rows)
-            await csvFile.write(rows, keys);
-        return csvFile;
-    }
-    static get csv() {
-        return FileTypeCsv;
-    }
-}
-/**
- * A generic file adaptor, extended by specific file type implementations
- */
-export class FileType {
-    file;
-    constructor(filepath, contents) {
-        this.file = new File(filepath);
-        if (contents)
-            this.file.write(contents);
-    }
-    get exists() {
-        return this.file.exists;
-    }
-    get path() {
-        return this.file.path;
-    }
-    delete() {
-        this.file.delete();
-    }
-}
-/**
- * A .json file that maintains data type when reading/writing.
- * This is unsafe! Type is not checked at runtime, avoid using on files manipulated outside of your application.
- */
-export class FileTypeJson extends FileType {
-    constructor(filepath, contents) {
-        super(filepath.endsWith('.json') ? filepath : filepath + '.json');
-        if (contents)
-            this.write(contents);
-    }
-    read() {
-        const contents = this.file.read();
-        return contents ? JSON.parse(contents) : undefined;
-    }
-    write(contents) {
-        this.file.write(JSON.stringify(snapshot(contents), null, 2));
-    }
-}
-/**
- * New-line delimited json file (.ndjson)
- * @see https://jsonltools.com/ndjson-format-specification
- */
-export class FileTypeNdjson extends FileType {
-    constructor(filepath, lines) {
-        super(filepath.endsWith('.ndjson') ? filepath : filepath + '.ndjson');
-        if (lines)
-            this.append(lines);
-    }
-    append(lines) {
-        this.file.append(Array.isArray(lines) ? lines.map((l) => JSON.stringify(snapshot(l))) : JSON.stringify(snapshot(lines)));
-    }
-    lines() {
-        return this.file.lines().map((l) => JSON.parse(l));
-    }
-}
-/**
- * Comma separated values (.csv).
- * Input rows as objects, keys are used as column headers
- */
-export class FileTypeCsv extends FileType {
-    constructor(filepath) {
-        super(filepath.endsWith('.csv') ? filepath : filepath + '.csv');
-    }
-    async write(rows, keys) {
-        const headerSet = new Set();
-        if (keys) {
-            for (const key of keys)
-                headerSet.add(key);
-        }
-        else {
-            for (const row of rows) {
-                for (const key in row)
-                    headerSet.add(key);
-            }
-        }
-        const headers = Array.from(headerSet);
-        const outRows = rows.map((row) => headers.map((key) => row[key]));
-        return finished(writeToStream(this.file.writeStream, [headers, ...outRows]));
-    }
-    #parseVal(val) {
-        if (val.toLowerCase() === 'false')
-            return false;
-        if (val.toLowerCase() === 'true')
-            return true;
-        if (val.length === 0)
-            return null;
-        if (/^[\.0-9]+$/.test(val))
-            return Number(val);
-        return val;
-    }
-    async read() {
-        return new Promise((resolve, reject) => {
-            const parsed = [];
-            parseStream(this.file.readStream, { headers: true })
-                .on('error', (e) => reject(e))
-                .on('data', (raw) => {
-                parsed.push(Object.entries(raw).reduce((all, [key, val]) => ({
-                    ...all,
-                    [key]: this.#parseVal(val),
-                }), {}));
-            })
-                .on('end', () => resolve(parsed));
-        });
-    }
-}

package/dist/Log.d.ts

@@ -1,43 +0,0 @@
-import { type ChalkInstance } from 'chalk';
-type Severity = 'DEFAULT' | 'DEBUG' | 'INFO' | 'NOTICE' | 'WARNING' | 'ERROR' | 'CRITICAL' | 'ALERT' | 'EMERGENCY';
-type Options = {
-    severity: Severity;
-    color: ChalkInstance;
-};
-export declare class Log {
-    #private;
-    static isTest: boolean;
-    /**
-     * Handle first argument being a string or an object with a 'message' prop
-     * Also snapshots special objects (eg Error, Response) to keep props in later JSON.stringify output
-     */
-    static prepare(...input: unknown[]): {
-        message?: string;
-        details: unknown[];
-    };
-    /**
-     * Logs error details before throwing
-     */
-    static error(...input: unknown[]): void;
-    static warn(...input: unknown[]): {
-        message: string | undefined;
-        details: unknown[];
-        options: Options;
-    };
-    static notice(...input: unknown[]): {
-        message: string | undefined;
-        details: unknown[];
-        options: Options;
-    };
-    static info(...input: unknown[]): {
-        message: string | undefined;
-        details: unknown[];
-        options: Options;
-    };
-    static debug(...input: unknown[]): {
-        message: string | undefined;
-        details: unknown[];
-        options: Options;
-    } | undefined;
-}
-export {};

package/dist/Log.js

@@ -1,80 +0,0 @@
-import { inspect } from 'node:util';
-import { isObjectLike } from 'lodash-es';
-import chalk from 'chalk';
-import { snapshot } from './snapshot.js';
-export class Log {
-    // Only silence logs when THIS package is running its own tests
-    static isTest = process.env.npm_package_name === '@brianbuie/node-kit' && process.env.npm_lifecycle_event === 'test';
-    /**
-     * Gcloud parses JSON in stdout
-     */
-    static #toGcloud(entry) {
-        if (entry.details?.length === 1) {
-            console.log(JSON.stringify({ ...entry, details: entry.details[0] }));
-        }
-        else {
-            console.log(JSON.stringify(entry));
-        }
-    }
-    /**
-     * Includes colors and better inspection for logging during dev
-     */
-    static #toConsole(entry, color) {
-        if (entry.message)
-            console.log(color(`[${entry.severity}] ${entry.message}`));
-        entry.details?.forEach((detail) => {
-            console.log(inspect(detail, { depth: 10, breakLength: 100, compact: true, colors: true }));
-        });
-    }
-    static #log(options, ...input) {
-        const { message, details } = this.prepare(...input);
-        // https://cloud.google.com/run/docs/container-contract#env-vars
-        const isGcloud = process.env.K_SERVICE !== undefined || process.env.CLOUD_RUN_JOB !== undefined;
-        if (isGcloud) {
-            this.#toGcloud({ message, severity: options.severity, details });
-            return { message, details, options };
-        }
-        // Hide output while testing this package
-        if (!this.isTest) {
-            this.#toConsole({ message, severity: options.severity, details }, options.color);
-        }
-        return { message, details, options };
-    }
-    /**
-     * Handle first argument being a string or an object with a 'message' prop
-     * Also snapshots special objects (eg Error, Response) to keep props in later JSON.stringify output
-     */
-    static prepare(...input) {
-        let [first, ...rest] = input.map((i) => snapshot(i));
-        if (typeof first === 'string')
-            return { message: first, details: rest };
-        // @ts-ignore
-        if (isObjectLike(first) && typeof first['message'] === 'string') {
-            const { message, ...firstDetails } = first;
-            return { message, details: [firstDetails, ...rest] };
-        }
-        return { details: input };
-    }
-    /**
-     * Logs error details before throwing
-     */
-    static error(...input) {
-        const { message } = this.#log({ severity: 'ERROR', color: chalk.red }, ...input);
-        throw new Error(message);
-    }
-    static warn(...input) {
-        return this.#log({ severity: 'WARNING', color: chalk.yellow }, ...input);
-    }
-    static notice(...input) {
-        return this.#log({ severity: 'NOTICE', color: chalk.cyan }, ...input);
-    }
-    static info(...input) {
-        return this.#log({ severity: 'INFO', color: chalk.white }, ...input);
-    }
-    static debug(...input) {
-        const debugging = process.argv.some((arg) => arg.includes('--debug')) || process.env.DEBUG !== undefined;
-        if (debugging || process.env.NODE_ENV !== 'production') {
-            return this.#log({ severity: 'DEBUG', color: chalk.gray }, ...input);
-        }
-    }
-}