@brianbuie/node-kit 0.5.0 → 0.5.2

package/dist/Cache.d.ts

@@ -10,6 +10,7 @@ export declare class Cache<T> {
         }): void;
         file: import("./File.js").File;
         get exists(): boolean;
+        delete(): void;
         get path(): string;
     };
     ttl: number;

package/dist/Dir.js

@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import sanitizeFilename from 'sanitize-filename';
 import { File } from './File.js';
 /**

package/dist/Fetcher.d.ts

@@ -17,17 +17,26 @@ export type FetchOptions = RequestInit & {
  */
 export declare class Fetcher {
     defaultOptions: {
-        timeout: number;
-        retries: number;
-        retryDelay: number;
-    } & RequestInit & {
+        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;
-        headers?: Record<string, string>;
         data?: any;
-        timeout?: number;
-        retries?: number;
-        retryDelay?: number;
+        timeout: number;
+        retries: number;
+        retryDelay: number;
     };
     constructor(opts?: FetchOptions);
     /**
@@ -35,6 +44,10 @@ export declare class Fetcher {
      * 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

package/dist/Fetcher.js

@@ -8,12 +8,12 @@ import extractDomain from 'extract-domain';
 export class Fetcher {
     defaultOptions;
     constructor(opts = {}) {
-        const defaultOptions = {
+        this.defaultOptions = {
             timeout: 60000,
             retries: 0,
             retryDelay: 3000,
+            ...opts,
         };
-        this.defaultOptions = merge(defaultOptions, opts);
     }
     /**
      * Build URL with URLSearchParams if query is provided
@@ -39,6 +39,13 @@ export class Fetcher {
         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
@@ -46,8 +53,8 @@ export class Fetcher {
     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 = init.headers || {};
             init.headers['content-type'] = init.headers['content-type'] || 'application/json';
             init.method = init.method || 'POST';
             init.body = JSON.stringify(data);
@@ -70,7 +77,6 @@ export class Fetcher {
         let attempt = 0;
         while (attempt < maxAttempts) {
             attempt++;
-            // Rebuild request on every attempt to reset AbortSignal.timeout
             const [req] = this.buildRequest(route, opts);
             const res = await fetch(req)
                 .then((r) => {

package/dist/File.d.ts

@@ -1,7 +1,13 @@
+import * as fs from 'node:fs';
+/**
+ * WARNING: API will change!
+ */
 export declare class File {
     path: string;
     constructor(filepath: string);
     get exists(): boolean;
+    createWriteStream(options?: Parameters<typeof fs.createWriteStream>[1]): fs.WriteStream;
+    delete(): void;
     read(): string | undefined;
     write(contents: string): void;
     /**
@@ -13,26 +19,35 @@ export declare class File {
      * @returns lines as strings, removes trailing '\n'
      */
     lines(): string[];
-    static get Adaptor(): typeof FileAdaptor;
+    static get Adaptor(): typeof Adaptor;
     json<T>(contents?: T): JsonFile<T>;
     static get json(): typeof JsonFile;
-    ndjson<T>(contents?: T): NdjsonFile<T>;
+    ndjson<T extends object>(lines?: T | T[]): NdjsonFile<T>;
     static get ndjson(): typeof NdjsonFile;
+    csv<T extends object>(rows?: T[], keys?: (keyof T)[]): Promise<CsvFile<T>>;
+    static get csv(): typeof CsvFile;
 }
-declare class FileAdaptor<T = string> {
+declare class Adaptor<T = string> {
     file: File;
     constructor(filepath: string, contents?: T);
     get exists(): boolean;
+    delete(): void;
     get path(): string;
 }
-declare class JsonFile<T> extends FileAdaptor {
+declare class JsonFile<T> extends Adaptor {
     constructor(filepath: string, contents?: T);
     read(): T | undefined;
     write(contents: T): void;
 }
-declare class NdjsonFile<T> extends FileAdaptor {
-    constructor(filepath: string, contents?: T);
+declare class NdjsonFile<T extends object> extends Adaptor {
+    constructor(filepath: string, lines?: T | T[]);
     append(lines: T | T[]): void;
     lines(): T[];
 }
+type Key<T extends object> = keyof T;
+declare class CsvFile<Row extends object> extends Adaptor {
+    constructor(filepath: string);
+    write(rows: Row[], keys?: Key<Row>[]): Promise<void>;
+    read(): Promise<Row[]>;
+}
 export {};

package/dist/File.js

@@ -1,6 +1,10 @@
-import fs from 'fs';
-import path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { writeToString, parseString } from 'fast-csv';
 import { snapshot } from './snapshot.js';
+/**
+ * WARNING: API will change!
+ */
 export class File {
     path;
     constructor(filepath) {
@@ -9,6 +13,12 @@ export class File {
     get exists() {
         return fs.existsSync(this.path);
     }
+    createWriteStream(options = {}) {
+        return fs.createWriteStream(this.path, options);
+    }
+    delete() {
+        fs.rmSync(this.path, { force: true });
+    }
     read() {
         return this.exists ? fs.readFileSync(this.path, 'utf8') : undefined;
     }
@@ -34,7 +44,7 @@ export class File {
         return contents.slice(0, contents.length - 1);
     }
     static get Adaptor() {
-        return FileAdaptor;
+        return Adaptor;
     }
     json(contents) {
         return new JsonFile(this.path, contents);
@@ -42,14 +52,23 @@ export class File {
     static get json() {
         return JsonFile;
     }
-    ndjson(contents) {
-        return new NdjsonFile(this.path, contents);
+    ndjson(lines) {
+        return new NdjsonFile(this.path, lines);
     }
     static get ndjson() {
         return NdjsonFile;
     }
+    async csv(rows, keys) {
+        const csvFile = new CsvFile(this.path);
+        if (rows)
+            await csvFile.write(rows, keys);
+        return csvFile;
+    }
+    static get csv() {
+        return CsvFile;
+    }
 }
-class FileAdaptor {
+class Adaptor {
     file;
     constructor(filepath, contents) {
         this.file = new File(filepath);
@@ -63,11 +82,14 @@ class FileAdaptor {
     get exists() {
         return this.file.exists;
     }
+    delete() {
+        this.file.delete();
+    }
     get path() {
         return this.file.path;
     }
 }
-class JsonFile extends FileAdaptor {
+class JsonFile extends Adaptor {
     constructor(filepath, contents) {
         super(filepath.endsWith('.json') ? filepath : filepath + '.json');
         if (contents)
@@ -81,11 +103,11 @@ class JsonFile extends FileAdaptor {
         this.file.write(JSON.stringify(snapshot(contents), null, 2));
     }
 }
-class NdjsonFile extends FileAdaptor {
-    constructor(filepath, contents) {
+class NdjsonFile extends Adaptor {
+    constructor(filepath, lines) {
         super(filepath.endsWith('.ndjson') ? filepath : filepath + '.ndjson');
-        if (contents)
-            this.append(contents);
+        if (lines)
+            this.append(lines);
     }
     append(lines) {
         this.file.append(Array.isArray(lines) ? lines.map((l) => JSON.stringify(snapshot(l))) : JSON.stringify(snapshot(lines)));
@@ -94,3 +116,53 @@ class NdjsonFile extends FileAdaptor {
         return this.file.lines().map((l) => JSON.parse(l));
     }
 }
+class CsvFile extends Adaptor {
+    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.js

@@ -1,11 +1,10 @@
-import fs from 'fs';
-import { inspect } from 'util';
+import { inspect } from 'node:util';
 import { isObjectLike } from 'lodash-es';
 import chalk from 'chalk';
 import { snapshot } from './snapshot.js';
-const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
 export class Log {
-    static isTest = process.env.npm_package_name === packageJson.name && process.env.npm_lifecycle_event === 'test';
+    // 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
      */

package/dist/TypeWriter.js

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import * as fs from 'node:fs';
 import { merge } from 'lodash-es';
 import * as qt from 'quicktype-core';
 export class TypeWriter {

package/dist/_index.d.ts

@@ -1,6 +1,6 @@
 export { Dir, TempDir, temp } from './Dir.js';
 export { Cache } from './Cache.js';
-export { Fetcher, type Route, Query, FetchOptions } from './Fetcher.js';
+export { Fetcher, type Route, type Query, type FetchOptions } from './Fetcher.js';
 export { File } from './File.js';
 export { Jwt } from './Jwt.js';
 export { Log } from './Log.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brianbuie/node-kit",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "license": "ISC",
   "repository": {
     "type": "git",
@@ -13,7 +13,10 @@
   },
   "type": "module",
   "exports": {
-    ".": "./dist/_index.js"
+    ".": {
+      "types": "./dist/_index.d.ts",
+      "default": "./dist/_index.js"
+    }
   },
   "files": [
     "src",
@@ -27,6 +30,7 @@
   "dependencies": {
     "chalk": "^5.6.2",
     "extract-domain": "^5.0.2",
+    "fast-csv": "^5.0.5",
     "jsonwebtoken": "^9.0.2",
     "lodash-es": "^4.17.21",
     "quicktype-core": "^23.2.6",

package/src/Dir.ts

@@ -1,5 +1,5 @@
-import fs from 'fs';
-import path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import sanitizeFilename from 'sanitize-filename';
 import { File } from './File.js';
 import { snapshot } from './snapshot.js';

package/src/Fetcher.ts

@@ -25,12 +25,12 @@ export class Fetcher {
   defaultOptions;
 
   constructor(opts: FetchOptions = {}) {
-    const defaultOptions = {
+    this.defaultOptions = {
       timeout: 60000,
       retries: 0,
       retryDelay: 3000,
+      ...opts,
     };
-    this.defaultOptions = merge(defaultOptions, opts);
   }
 
   /**
@@ -56,6 +56,14 @@ export class Fetcher {
     return [url, domain];
   }
 
+  /**
+   * Merges options to get headers. Useful when extending the Fetcher class to add custom auth.
+   */
+  buildHeaders(route: Route, opts: FetchOptions = {}) {
+    const { headers } = merge({}, this.defaultOptions, opts);
+    return headers || {};
+  }
+
   /**
    * Builds request, merging defaultOptions and provided options
    * Includes Abort signal for timeout
@@ -63,8 +71,8 @@ export class Fetcher {
   buildRequest(route: Route, opts: FetchOptions = {}): [Request, FetchOptions, string] {
     const mergedOptions = merge({}, this.defaultOptions, opts);
     const { query, data, timeout, retries, ...init } = mergedOptions;
+    init.headers = this.buildHeaders(route, mergedOptions);
     if (data) {
-      init.headers = init.headers || {};
       init.headers['content-type'] = init.headers['content-type'] || 'application/json';
       init.method = init.method || 'POST';
       init.body = JSON.stringify(data);
@@ -88,7 +96,6 @@ export class Fetcher {
     let attempt = 0;
     while (attempt < maxAttempts) {
       attempt++;
-      // Rebuild request on every attempt to reset AbortSignal.timeout
       const [req] = this.buildRequest(route, opts);
       const res = await fetch(req)
         .then((r) => {

package/src/File.test.ts

@@ -1,6 +1,5 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
-import { isEqual } from 'lodash-es';
 import { temp } from './Dir.js';
 import { File } from './File.js';
 
@@ -11,14 +10,14 @@ const thing = {
   a: 'string',
   b: 2,
   c: true,
-  d: null,
+  d: false,
+  e: null,
 };
 
 describe('FileAdaptor', () => {
-  it('Instances can be created', () => {
+  it('Creates instances', () => {
     const test1 = new File.Adaptor(testDir.filepath('test1.txt'));
     assert(test1.file.path.includes('test1.txt'));
-
     const base = 'test2';
     const eg1 = new File.json(testDir.filepath(base));
     const eg2 = testDir.file(base).json();
@@ -26,17 +25,26 @@ describe('FileAdaptor', () => {
     const eg3 = eg3File.json();
     assert(eg1.path === eg2.path && eg2.path === eg3.path);
   });
+
+  it('Deletes files', () => {
+    const test = testDir.file('delete-test.txt');
+    test.write('test');
+    assert.equal(test.read(), 'test');
+    test.delete();
+    assert.equal(test.exists, false);
+  });
 });
 
 describe('File.ndjson', () => {
   it('Appends new lines correctly', () => {
-    const file = testDir.file('empty-lines').ndjson();
+    const file = testDir.file('appends-lines').ndjson();
+    file.delete();
     file.append([thing, thing]);
     assert(file.lines().length === 2);
     file.append(thing);
     assert(file.lines().length === 3);
     file.lines().forEach((line) => {
-      assert(isEqual(line, thing));
+      assert.deepStrictEqual(line, thing);
     });
   });
 
@@ -52,9 +60,9 @@ describe('File.ndjson', () => {
 describe('File.json', () => {
   it('Saves data as json', () => {
     const file = testDir.file('jsonfile-data').json(thing);
-    assert(isEqual(file.read(), thing));
+    assert.deepStrictEqual(file.read(), thing);
     file.write(thing);
-    assert(isEqual(file.read(), thing));
+    assert.deepStrictEqual(file.read(), thing);
   });
 
   it('Does not create file when reading', () => {
@@ -64,3 +72,14 @@ describe('File.json', () => {
     assert(!file.exists);
   });
 });
+
+describe('File.csv', () => {
+  it('Saves data as csv', async () => {
+    const things = [thing, thing, thing];
+    const file = await testDir.file('csv-data').csv(things);
+    const parsed = await file.read();
+    parsed.forEach((row) => {
+      assert.deepEqual(row, thing);
+    });
+  });
+});

package/src/File.ts

@@ -1,7 +1,11 @@
-import fs from 'fs';
-import path from 'path';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { writeToString, parseString } from 'fast-csv';
 import { snapshot } from './snapshot.js';
 
+/**
+ * WARNING: API will change!
+ */
 export class File {
   path;
 
@@ -13,6 +17,14 @@ export class File {
     return fs.existsSync(this.path);
   }
 
+  createWriteStream(options: Parameters<typeof fs.createWriteStream>[1] = {}) {
+    return fs.createWriteStream(this.path, options);
+  }
+
+  delete() {
+    fs.rmSync(this.path, { force: true });
+  }
+
   read() {
     return this.exists ? fs.readFileSync(this.path, 'utf8') : undefined;
   }
@@ -41,7 +53,7 @@ export class File {
   }
 
   static get Adaptor() {
-    return FileAdaptor;
+    return Adaptor;
   }
 
   json<T>(contents?: T) {
@@ -52,16 +64,26 @@ export class File {
     return JsonFile;
   }
 
-  ndjson<T>(contents?: T) {
-    return new NdjsonFile<T>(this.path, contents);
+  ndjson<T extends object>(lines?: T | T[]) {
+    return new NdjsonFile<T>(this.path, lines);
   }
 
   static get ndjson() {
     return NdjsonFile;
   }
+
+  async csv<T extends object>(rows?: T[], keys?: (keyof T)[]) {
+    const csvFile = new CsvFile<T>(this.path);
+    if (rows) await csvFile.write(rows, keys);
+    return csvFile;
+  }
+
+  static get csv() {
+    return CsvFile;
+  }
 }
 
-class FileAdaptor<T = string> {
+class Adaptor<T = string> {
   file;
 
   constructor(filepath: string, contents?: T) {
@@ -78,12 +100,16 @@ class FileAdaptor<T = string> {
     return this.file.exists;
   }
 
+  delete() {
+    this.file.delete();
+  }
+
   get path() {
     return this.file.path;
   }
 }
 
-class JsonFile<T> extends FileAdaptor {
+class JsonFile<T> extends Adaptor {
   constructor(filepath: string, contents?: T) {
     super(filepath.endsWith('.json') ? filepath : filepath + '.json');
     if (contents) this.write(contents);
@@ -99,10 +125,10 @@ class JsonFile<T> extends FileAdaptor {
   }
 }
 
-class NdjsonFile<T> extends FileAdaptor {
-  constructor(filepath: string, contents?: T) {
+class NdjsonFile<T extends object> extends Adaptor {
+  constructor(filepath: string, lines?: T | T[]) {
     super(filepath.endsWith('.ndjson') ? filepath : filepath + '.ndjson');
-    if (contents) this.append(contents);
+    if (lines) this.append(lines);
   }
 
   append(lines: T | T[]) {
@@ -115,3 +141,55 @@ class NdjsonFile<T> extends FileAdaptor {
     return this.file.lines().map((l) => JSON.parse(l) as T);
   }
 }
+
+type Key<T extends object> = keyof T;
+
+class CsvFile<Row extends object> extends Adaptor {
+  constructor(filepath: string) {
+    super(filepath.endsWith('.csv') ? filepath : filepath + '.csv');
+  }
+
+  async write(rows: Row[], keys?: Key<Row>[]) {
+    const headerSet = new Set<Key<Row>>();
+    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<Row[]>((resolve, reject) => {
+      const parsed: Row[] = [];
+      const content = this.file.read();
+      if (!content) return resolve(parsed);
+      function parseVal(val: string) {
+        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: Record<Key<Row>, string>) => {
+          parsed.push(
+            Object.entries(raw).reduce(
+              (all, [key, val]) => ({
+                ...all,
+                [key]: parseVal(val as string),
+              }),
+              {} as Row
+            )
+          );
+        });
+    });
+  }
+}

package/src/Log.ts

@@ -1,11 +1,8 @@
-import fs from 'fs';
-import { inspect } from 'util';
+import { inspect } from 'node:util';
 import { isObjectLike } from 'lodash-es';
 import chalk, { type ChalkInstance } from 'chalk';
 import { snapshot } from './snapshot.js';
 
-const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-
 type Severity = 'DEFAULT' | 'DEBUG' | 'INFO' | 'NOTICE' | 'WARNING' | 'ERROR' | 'CRITICAL' | 'ALERT' | 'EMERGENCY';
 
 type Options = {
@@ -20,7 +17,8 @@ type Entry = {
 };
 
 export class Log {
-  static isTest = process.env.npm_package_name === packageJson.name && process.env.npm_lifecycle_event === 'test';
+  // 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

package/src/TypeWriter.ts

@@ -1,4 +1,4 @@
-import fs from 'fs';
+import * as fs from 'node:fs';
 import { merge } from 'lodash-es';
 import * as qt from 'quicktype-core';
 

package/src/_index.ts

@@ -1,6 +1,6 @@
 export { Dir, TempDir, temp } from './Dir.js';
 export { Cache } from './Cache.js';
-export { Fetcher, type Route, Query, FetchOptions } from './Fetcher.js';
+export { Fetcher, type Route, type Query, type FetchOptions } from './Fetcher.js';
 export { File } from './File.js';
 export { Jwt } from './Jwt.js';
 export { Log } from './Log.js';