@tim-code/my-util 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "",
   "type": "module",
   "author": "Tim Sprowl",

package/src/find.js

@@ -153,6 +153,7 @@ export function findClosestGTE(array, desired, { key, cutoff = Infinity } = {})
 
 /**
  * Find the closest element in an array. If there is a tie, then returns the first matching element by order in the array.
+ * If some values are undefined or null, they will be ignored. If no element is found, returns undefined.
  * If using for strings, need to specify different values for "cutoff" and "comparator".
  * "~" and "" are good cutoff string values for gt/gte and lt/lte respectively.
  * @template T, V

package/src/fs.js

@@ -1,47 +1,40 @@
 import { readFile, stat, writeFile } from "node:fs/promises"
 import { tmpdir } from "node:os"
 import { promisify } from "node:util"
-import { gunzip as _gunzip } from "node:zlib"
+import { gunzip as _gunzip, gzip as _gzip } from "node:zlib"
 
 const gunzip = promisify(_gunzip)
+const gzip = promisify(_gzip)
 
 // the integration tests for this file are the s3-fs integration tests in lambda-integrations
 // changes to this file should be tested against lambda-integrations' integration tests
 
 /**
- * Get JSON from a path.
+ * Get JSON from a path. If path ends with .gz, will automatically decompress data.
  * @param {string} path
  * @returns {Object|Array}
  */
-export async function getJSON(path) {
-  const buffer = await readFile(path)
+export async function readJSON(path) {
+  let buffer = await readFile(path)
+  if (path.endsWith(".gz")) {
+    buffer = await gunzip(buffer)
+  }
   return JSON.parse(buffer.toString())
 }
 
 /**
- * Write JSON to a path.
+ * Write JSON to a path. If path ends with .gz, will automatically compress data.
  * @param {string} path
  * @param {Object|Array} object
  * @param {Object} $1
  * @param {number=} $1.indent Indent used to format JSON object. Default 2. If 0, does not indent object.
  */
 export async function writeJSON(path, object, { indent = 2 } = {}) {
-  const string = JSON.stringify(object, undefined, indent)
-  await writeFile(path, string)
-}
-
-/**
- * Get gzipped JSON from a path.
- * @param {string} path
- * @returns {Object|Array}
- */
-export async function getCompressedJSON(path) {
-  if (!path.endsWith(".gz")) {
-    throw new Error("path does not suggest a compressed file")
+  let data = JSON.stringify(object, undefined, indent)
+  if (path.endsWith(".gz")) {
+    data = await gzip(data)
   }
-  const buffer = await readFile(path)
-  const uncompressed = await gunzip(buffer)
-  return JSON.parse(uncompressed.toString())
+  await writeFile(path, data)
 }
 
 /**

package/src/fs.test.js

@@ -4,6 +4,7 @@ const readFileMock = jest.fn()
 const statMock = jest.fn()
 const tmpdirMock = jest.fn()
 const gunzipMock = jest.fn()
+const gzipMock = jest.fn()
 const writeFileMock = jest.fn()
 jest.unstable_mockModule("node:fs/promises", () => ({
   readFile: readFileMock,
@@ -15,6 +16,7 @@ jest.unstable_mockModule("node:os", () => ({
 }))
 jest.unstable_mockModule("node:zlib", () => ({
   gunzip: gunzipMock,
+  gzip: gzipMock,
 }))
 jest.unstable_mockModule("node:util", () => ({
   promisify: (mock) => mock,
@@ -22,16 +24,24 @@ jest.unstable_mockModule("node:util", () => ({
 
 // Now import the module under test
 const mod = await import("./fs.js")
-const { getJSON, writeJSON, getCompressedJSON, pathExists, makeTempDirectory } = mod
+const { readJSON, writeJSON, pathExists, makeTempDirectory } = mod
 
-describe("getJSON", () => {
+describe("readJSON", () => {
   beforeEach(() => jest.clearAllMocks())
   it("parses JSON from file", async () => {
     readFileMock.mockResolvedValue(Buffer.from('{"a":1}'))
-    const result = await getJSON("foo.json")
+    const result = await readJSON("foo.json")
     expect(result).toEqual({ a: 1 })
     expect(readFileMock).toHaveBeenCalledWith("foo.json")
   })
+  it("decompresses and parses JSON from .gz file", async () => {
+    readFileMock.mockResolvedValue(Buffer.from("gzipped"))
+    gunzipMock.mockResolvedValue(Buffer.from('{"b":2}'))
+    const result = await readJSON("bar.gz")
+    expect(result).toEqual({ b: 2 })
+    expect(readFileMock).toHaveBeenCalledWith("bar.gz")
+    expect(gunzipMock).toHaveBeenCalledWith(Buffer.from("gzipped"))
+  })
 })
 
 describe("writeJSON", () => {
@@ -55,20 +65,18 @@ describe("writeJSON", () => {
     await writeJSON("foo.json", { x: 2 }, { indent: 0 })
     expect(writeFileMock).toHaveBeenCalledWith("foo.json", '{"x":2}')
   })
-})
-
-describe("getCompressedJSON", () => {
-  beforeEach(() => jest.clearAllMocks())
-  it("reads, decompresses, and parses JSON", async () => {
-    readFileMock.mockResolvedValue(Buffer.from("gzipped"))
-    gunzipMock.mockResolvedValue(Buffer.from('{"b":2}'))
-    const result = await getCompressedJSON("bar.gz")
-    expect(result).toEqual({ b: 2 })
-    expect(readFileMock).toHaveBeenCalledWith("bar.gz")
-    expect(gunzipMock).toHaveBeenCalled()
-  })
-  it("throws for bad filename", async () => {
-    await expect(getCompressedJSON("bar")).rejects.toThrow(/a compressed file/u)
+  it("compresses and writes JSON to .gz file", async () => {
+    gzipMock.mockResolvedValue(Buffer.from("compressed"))
+    await writeJSON("foo.gz", { y: 3 })
+    // Should gzip the JSON string and write the compressed buffer
+    expect(gzipMock).toHaveBeenCalledWith(JSON.stringify({ y: 3 }, undefined, 2))
+    expect(writeFileMock).toHaveBeenCalledWith("foo.gz", Buffer.from("compressed"))
+  })
+  it("compresses and writes JSON with custom indent to .gz file", async () => {
+    gzipMock.mockResolvedValue(Buffer.from("compressed"))
+    await writeJSON("foo.gz", { y: 3 }, { indent: 0 })
+    expect(gzipMock).toHaveBeenCalledWith(JSON.stringify({ y: 3 }, undefined, 0))
+    expect(writeFileMock).toHaveBeenCalledWith("foo.gz", Buffer.from("compressed"))
   })
 })
 

package/src/promise.js

@@ -70,10 +70,15 @@ export async function sleep(ms) {
  * @param {Function=} $1.limiter A function awaited after a group of parallel calls is processed.
  *  It is called with the number of parallel calls processed. Could be as simple as `() => sleep(10000)` if you wanted to wait 10 seconds between.
  * @param {boolean=} $1.flatten Flattens values before returning; useful if promises return arrays
+ * @param {boolean=} $1.abort If true, will return early if there are errors.
+ *  If false (default), will process all elements in the array (like Promise.allSettled()).
  * @param {Function} callback
  * @returns {Object} {results, values, returned, errors}
  */
-export async function allSettled({ array, limit, limiter, flatten = false }, callback) {
+export async function allSettled(
+  { array, limit, limiter, flatten = false, abort = false },
+  callback
+) {
   const results = []
   let returned = []
   let values = []
@@ -92,6 +97,9 @@ export async function allSettled({ array, limit, limiter, flatten = false }, cal
         errors.push(reason)
       }
     }
+    if (abort && errors.length) {
+      break
+    }
     await limiter?.(elements.length)
   }
   if (flatten) {
@@ -139,6 +147,7 @@ export function alert(result) {
   return result
 }
 
+// unused but included for reference
 /**
  * Parallelize executions of a function using `Promise.all()`.
  * This is useful because usually you want to set a limit to the number of parallel requests possible at once.

package/src/promise.test.js

@@ -2,7 +2,15 @@
 /* eslint-disable prefer-promise-reject-errors */
 import { jest } from "@jest/globals"
 
-import { alert, allSettled, poll, PollError, sleep, throwFirstReject, intervalLimiter } from "./promise.js"
+import {
+  alert,
+  allSettled,
+  intervalLimiter,
+  poll,
+  PollError,
+  sleep,
+  throwFirstReject,
+} from "./promise.js"
 
 describe("poll", () => {
   it("resolves immediately if callback returns a non-undefined/null/false value", async () => {
@@ -182,6 +190,22 @@ describe("allSettled", () => {
     expect(limiter).toHaveBeenCalledTimes(3)
     expect(limiterCalls).toEqual([2, 2, 1])
   })
+
+  it("returns early if abort=true and any error occurs", async () => {
+    // Should process only up to the first chunk with a rejection, then stop
+    const arr = [1, 2, 3, 4, 5, 6]
+    const cb = jest
+      .fn()
+      .mockImplementation((x) => (x === 2 || x === 4 ? Promise.reject(`fail${x}`) : x))
+    // limit=2 so chunks: [1,2], [3,4], [5,6]
+    const result = await allSettled({ array: arr, limit: 2, abort: true }, cb)
+    // The first chunk: [1,2] => 1 fulfilled, 1 rejected
+    // Should stop after first chunk with error
+    expect(result.values.length).toBe(2)
+    expect(result.errors).toEqual(["fail2"])
+    expect(cb).toHaveBeenCalledTimes(2)
+    // Should not process [3,4] or [5,6]
+  })
 })
 
 describe("intervalLimiter", () => {