@brianbuie/node-kit 0.8.0 → 0.9.1

package/dist/Fetcher.d.ts

@@ -1,65 +0,0 @@
-export type Route = string | URL;
-type QueryVal = string | number | boolean | null | undefined;
-export type Query = Record<string, QueryVal | QueryVal[]>;
-export type FetchOptions = RequestInit & {
-    base?: string;
-    query?: Query;
-    headers?: Record<string, string>;
-    data?: any;
-    timeout?: number;
-    retries?: number;
-    retryDelay?: number;
-};
-/**
- * Fetcher provides a quick way to set up a basic API connection
- * with options applied to every request.
- * Includes basic methods for requesting and parsing responses
- */
-export declare class Fetcher {
-    defaultOptions: {
-        body?: BodyInit | null;
-        cache?: RequestCache;
-        credentials?: RequestCredentials;
-        headers?: (HeadersInit & Record<string, string>) | undefined;
-        integrity?: string;
-        keepalive?: boolean;
-        method?: string;
-        mode?: RequestMode;
-        priority?: RequestPriority;
-        redirect?: RequestRedirect;
-        referrer?: string;
-        referrerPolicy?: ReferrerPolicy;
-        signal?: AbortSignal | null;
-        window?: null;
-        base?: string;
-        query?: Query;
-        data?: any;
-        timeout: number;
-        retries: number;
-        retryDelay: number;
-    };
-    constructor(opts?: FetchOptions);
-    /**
-     * Build URL with URLSearchParams if query is provided.
-     * Also returns domain, to help with cookies
-     */
-    buildUrl(route: Route, opts?: FetchOptions): [URL, string];
-    /**
-     * Merges options to get headers. Useful when extending the Fetcher class to add custom auth.
-     */
-    buildHeaders(route: Route, opts?: FetchOptions): HeadersInit & Record<string, string>;
-    /**
-     * Builds request, merging defaultOptions and provided options.
-     * Includes Abort signal for timeout
-     */
-    buildRequest(route: Route, opts?: FetchOptions): [Request, FetchOptions, string];
-    /**
-     * Builds and performs the request, merging provided options with defaultOptions.
-     * If `opts.data` is provided, method is updated to POST, content-type json, data is stringified in the body.
-     * Retries on local or network error, with increasing backoff.
-     */
-    fetch(route: Route, opts?: FetchOptions): Promise<[Response, Request]>;
-    fetchText(route: Route, opts?: FetchOptions): Promise<[string, Response, Request]>;
-    fetchJson<T>(route: Route, opts?: FetchOptions): Promise<[T, Response, Request]>;
-}
-export {};

package/dist/Fetcher.js

@@ -1,111 +0,0 @@
-import { merge } from 'lodash-es';
-import extractDomain from 'extract-domain';
-/**
- * Fetcher provides a quick way to set up a basic API connection
- * with options applied to every request.
- * Includes basic methods for requesting and parsing responses
- */
-export class Fetcher {
-    defaultOptions;
-    constructor(opts = {}) {
-        this.defaultOptions = {
-            timeout: 60000,
-            retries: 0,
-            retryDelay: 3000,
-            ...opts,
-        };
-    }
-    /**
-     * Build URL with URLSearchParams if query is provided.
-     * Also returns domain, to help with cookies
-     */
-    buildUrl(route, opts = {}) {
-        const mergedOptions = merge({}, this.defaultOptions, opts);
-        const params = [];
-        Object.entries(mergedOptions.query || {}).forEach(([key, val]) => {
-            if (val === undefined)
-                return;
-            if (Array.isArray(val)) {
-                val.forEach((v) => {
-                    params.push([key, `${v}`]);
-                });
-            }
-            else {
-                params.push([key, `${val}`]);
-            }
-        });
-        const search = params.length > 0 ? '?' + new URLSearchParams(params).toString() : '';
-        const url = new URL(route + search, this.defaultOptions.base);
-        const domain = extractDomain(url.href);
-        return [url, domain];
-    }
-    /**
-     * Merges options to get headers. Useful when extending the Fetcher class to add custom auth.
-     */
-    buildHeaders(route, opts = {}) {
-        const { headers } = merge({}, this.defaultOptions, opts);
-        return headers || {};
-    }
-    /**
-     * Builds request, merging defaultOptions and provided options.
-     * Includes Abort signal for timeout
-     */
-    buildRequest(route, opts = {}) {
-        const mergedOptions = merge({}, this.defaultOptions, opts);
-        const { query, data, timeout, retries, ...init } = mergedOptions;
-        init.headers = this.buildHeaders(route, mergedOptions);
-        if (data) {
-            init.headers['content-type'] = init.headers['content-type'] || 'application/json';
-            init.method = init.method || 'POST';
-            init.body = JSON.stringify(data);
-        }
-        if (timeout) {
-            init.signal = AbortSignal.timeout(timeout);
-        }
-        const [url, domain] = this.buildUrl(route, mergedOptions);
-        const req = new Request(url, init);
-        return [req, mergedOptions, domain];
-    }
-    /**
-     * Builds and performs the request, merging provided options with defaultOptions.
-     * If `opts.data` is provided, method is updated to POST, content-type json, data is stringified in the body.
-     * Retries on local or network error, with increasing backoff.
-     */
-    async fetch(route, opts = {}) {
-        const [_req, options] = this.buildRequest(route, opts);
-        const maxAttempts = (options.retries || 0) + 1;
-        let attempt = 0;
-        while (attempt < maxAttempts) {
-            attempt++;
-            const [req] = this.buildRequest(route, opts);
-            const res = await fetch(req)
-                .then((r) => {
-                if (!r.ok)
-                    throw new Error(r.statusText);
-                return r;
-            })
-                .catch(async (error) => {
-                if (attempt < maxAttempts) {
-                    const wait = attempt * 3000;
-                    console.warn(`${req.method} ${req.url} (attempt ${attempt} of ${maxAttempts})`, error);
-                    await new Promise((resolve) => setTimeout(resolve, wait));
-                }
-                else {
-                    throw new Error(error);
-                }
-            });
-            if (res)
-                return [res, req];
-        }
-        throw new Error(`Failed to fetch ${_req.url}`);
-    }
-    async fetchText(route, opts = {}) {
-        return this.fetch(route, opts).then(async ([res, req]) => {
-            const text = await res.text();
-            return [text, res, req];
-        });
-    }
-    async fetchJson(route, opts = {}) {
-        return this.fetchText(route, opts).then(([txt, res, req]) => [JSON.parse(txt), res, req]);
-    }
-}

package/dist/File.d.ts

@@ -1,53 +0,0 @@
-import { Readable } from 'node:stream';
-/**
- * WARNING: API will change!
- */
-export declare class File {
-    path: string;
-    constructor(filepath: string);
-    get exists(): boolean;
-    delete(): void;
-    read(): string | undefined;
-    write(contents: string): void;
-    streamFrom(...options: Parameters<(typeof Readable)['from']>): Promise<void>;
-    /**
-     * 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: string | string[]): void;
-    /**
-     * @returns lines as strings, removes trailing '\n'
-     */
-    lines(): string[];
-    static get FileType(): typeof FileType;
-    json<T>(contents?: T): FileTypeJson<T>;
-    static get json(): typeof FileTypeJson;
-    ndjson<T extends object>(lines?: T | T[]): FileTypeNdjson<T>;
-    static get ndjson(): typeof FileTypeNdjson;
-    csv<T extends object>(rows?: T[], keys?: (keyof T)[]): Promise<FileTypeCsv<T>>;
-    static get csv(): typeof FileTypeCsv;
-}
-export declare class FileType<T = string> {
-    file: File;
-    constructor(filepath: string, contents?: T);
-    get exists(): boolean;
-    delete(): void;
-    get path(): string;
-}
-export declare class FileTypeJson<T> extends FileType {
-    constructor(filepath: string, contents?: T);
-    read(): T | undefined;
-    write(contents: T): void;
-}
-export declare class FileTypeNdjson<T extends object> extends FileType {
-    constructor(filepath: string, lines?: T | T[]);
-    append(lines: T | T[]): void;
-    lines(): T[];
-}
-type Key<T extends object> = keyof T;
-export declare class FileTypeCsv<Row extends object> extends FileType {
-    constructor(filepath: string);
-    write(rows: Row[], keys?: Key<Row>[]): Promise<void>;
-    read(): Promise<Row[]>;
-}
-export {};

package/dist/File.js

@@ -1,170 +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 { writeToString, parseString } 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;
-    }
-    write(contents) {
-        fs.mkdirSync(path.parse(this.path).dir, { recursive: true });
-        fs.writeFileSync(this.path, contents);
-    }
-    async streamFrom(...options) {
-        return finished(Readable.from(...options).pipe(fs.createWriteStream(this.path)));
-    }
-    /**
-     * 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');
-    }
-    /**
-     * @returns lines as strings, removes trailing '\n'
-     */
-    lines() {
-        const contents = (this.read() || '').split('\n');
-        return contents.slice(0, contents.length - 1);
-    }
-    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;
-    }
-}
-export class FileType {
-    file;
-    constructor(filepath, contents) {
-        this.file = new File(filepath);
-        if (contents) {
-            if (typeof contents !== 'string') {
-                throw new Error('File contents must be a string');
-            }
-            this.file.write(contents);
-        }
-    }
-    get exists() {
-        return this.file.exists;
-    }
-    delete() {
-        this.file.delete();
-    }
-    get path() {
-        return this.file.path;
-    }
-}
-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));
-    }
-}
-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));
-    }
-}
-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]));
-        const contents = await writeToString([headers, ...outRows]);
-        this.file.write(contents);
-    }
-    async read() {
-        return new Promise((resolve, reject) => {
-            const parsed = [];
-            const content = this.file.read();
-            if (!content)
-                return resolve(parsed);
-            function 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;
-            }
-            parseString(content, { headers: true })
-                .on('error', (e) => reject(e))
-                .on('end', () => resolve(parsed))
-                .on('data', (raw) => {
-                parsed.push(Object.entries(raw).reduce((all, [key, val]) => ({
-                    ...all,
-                    [key]: parseVal(val),
-                }), {}));
-            });
-        });
-    }
-}

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);
-        }
-    }
-}