Type utils and wait and retry from node-core

packages/app/universal-ts-utils/src/node.ts

@@ -22,3 +22,11 @@ export * from './public/object/groupByUnique.js'
 export * from './public/object/isEmpty.js'
 export * from './public/object/pick.js'
 export * from './public/object/transformToKebabCase.js'
+
+// type
+export * from './public/type/hasMessage.js'
+export * from './public/type/isError.js'
+export * from './public/type/isObject.js'
+export * from './public/type/isStandardizedError.js'
+
+export * from './public/waitAndRetry.js'

packages/app/universal-ts-utils/src/public/object/copyWithoutNullish.spec.ts

@@ -11,7 +11,14 @@ describe('copyWithoutNullish', () => {
       e: {},
     })
 
-    expect(result).toMatchSnapshot()
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "a": "a",
+        "b": "",
+        "c": " ",
+        "e": {},
+      }
+    `)
   })
 
   it('Removes undefined fields', () => {

packages/app/universal-ts-utils/src/public/type/hasMessage.spec.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest'
+import { hasMessage } from './hasMessage.js'
+
+describe('hasMessage', () => {
+  it('true for something with message', () => {
+    const obj = {
+      message: 'hello',
+    }
+
+    expect(hasMessage(obj)).toBe(true)
+  })
+
+  it('false for something without message', () => {
+    const obj = {
+      hello: 'world',
+    }
+
+    expect(hasMessage(obj)).toBe(false)
+  })
+})

packages/app/universal-ts-utils/src/public/type/hasMessage.ts

@@ -0,0 +1,4 @@
+import { isObject } from './isObject.js'
+
+export const hasMessage = (maybe: unknown): maybe is { message: string } =>
+  isObject(maybe) && typeof maybe.message === 'string'

packages/app/universal-ts-utils/src/public/type/isError.spec.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import { isError } from './isError.js'
+
+describe('isError', () => {
+  it('true for Error', () => {
+    const error = new Error('')
+
+    expect(isError(error)).toBe(true)
+  })
+
+  it('true for Error extension', () => {
+    class MyError extends Error {}
+    const error = new MyError('')
+
+    expect(isError(error)).toBe(true)
+  })
+
+  it('true for Error', () => {
+    const error = new Error('bam')
+
+    expect(isError(error)).toBe(true)
+  })
+
+  it('false for string', () => {
+    const error = 'bam'
+
+    expect(isError(error)).toBe(false)
+  })
+
+  it('false for a number', () => {
+    const error = 43
+
+    expect(isError(error)).toBe(false)
+  })
+
+  it('false for a plain object', () => {
+    const error = {}
+
+    expect(isError(error)).toBe(false)
+  })
+})

packages/app/universal-ts-utils/src/public/type/isError.ts

@@ -0,0 +1,2 @@
+export const isError = (maybeError: unknown): maybeError is Error =>
+  maybeError instanceof Error || Object.prototype.toString.call(maybeError) === '[object Error]'

packages/app/universal-ts-utils/src/public/type/isObject.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+import { isObject } from './isObject.js'
+
+describe('isObject', () => {
+  it('true for object', () => {
+    const error = new Error('error')
+
+    expect(isObject(error)).toBe(true)
+  })
+
+  it('false for non-object', () => {
+    const error = 'error'
+
+    expect(isObject(error)).toBe(false)
+  })
+
+  it('false for null', () => {
+    const error = null
+
+    expect(isObject(error)).toBe(false)
+  })
+})

packages/app/universal-ts-utils/src/public/type/isObject.ts

@@ -0,0 +1,2 @@
+export const isObject = (maybeObject: unknown): maybeObject is Record<PropertyKey, unknown> =>
+  typeof maybeObject === 'object' && maybeObject !== null

packages/app/universal-ts-utils/src/public/type/isStandardizedError.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+import { isStandardizedError } from './isStandardizedError.js'
+
+describe('isStandardizedError', () => {
+  it('true for standardized error', () => {
+    const error = {
+      message: 'dummy',
+      code: 'code',
+    }
+
+    expect(isStandardizedError(error)).toBe(true)
+  })
+
+  it('false for non standardized error', () => {
+    const error = new Error()
+
+    expect(isStandardizedError(error)).toBe(false)
+  })
+})

packages/app/universal-ts-utils/src/public/type/isStandardizedError.ts

@@ -0,0 +1,10 @@
+import { isObject } from './isObject.js'
+
+// Error structure commonly used in libraries, e. g. fastify
+export type StandardizedError = {
+  code: string
+  message: string
+}
+
+export const isStandardizedError = (error: unknown): error is StandardizedError =>
+  isObject(error) && typeof error.code === 'string' && typeof error.message === 'string'

packages/app/universal-ts-utils/src/public/waitAndRetry.spec.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+
+import { waitAndRetry } from './waitAndRetry.js'
+
+class Counter {
+  private readonly timeOfSucces: number
+  public executionCounter: number
+  constructor(msecsTillSuccess: number) {
+    this.timeOfSucces = Date.now() + msecsTillSuccess
+    this.executionCounter = 0
+  }
+
+  process() {
+    this.executionCounter++
+    return Date.now() >= this.timeOfSucces
+  }
+}
+
+describe('waitUtils', () => {
+  describe('waitAndRetry', () => {
+    it('executes once if there is an instant condition match', async () => {
+      const counter = new Counter(0)
+
+      const result = await waitAndRetry(() => {
+        return counter.process()
+      })
+
+      expect(result).toBe(true)
+      expect(counter.executionCounter).toBe(1)
+    })
+
+    it('executes until there is a condition match', async () => {
+      const counter = new Counter(1000)
+
+      const result = await waitAndRetry(
+        () => {
+          return counter.process()
+        },
+        50,
+        30,
+      )
+
+      expect(result).toBe(true)
+      expect(counter.executionCounter > 0).toBe(true)
+    })
+
+    it('times out of there is never a condition match', async () => {
+      const counter = new Counter(1000)
+
+      const result = await waitAndRetry(
+        () => {
+          return counter.process()
+        },
+        20,
+        30,
+      )
+
+      expect(result).toBe(false)
+      expect(counter.executionCounter > 0).toBe(true)
+    })
+
+    it('handles an error', async () => {
+      await expect(
+        waitAndRetry(() => {
+          throw new Error('it broke')
+        }),
+      ).rejects.toThrowError('it broke')
+    })
+  })
+})

packages/app/universal-ts-utils/src/public/waitAndRetry.ts

@@ -0,0 +1,33 @@
+export const waitAndRetry = async <T>(
+  predicateFn: () => T,
+  sleepTime = 20,
+  maxRetryCount = 15,
+): Promise<T> => {
+  return new Promise((resolve, reject) => {
+    let retryCount = 0
+
+    const performCheck = () => {
+      // amount of retries exceeded
+      if (maxRetryCount !== 0 && retryCount > maxRetryCount) {
+        resolve(predicateFn())
+        return
+      }
+
+      // Try executing predicateFn
+      Promise.resolve()
+        .then(() => predicateFn())
+        .then((result) => {
+          if (result) {
+            resolve(result)
+            return
+          }
+
+          retryCount++
+          setTimeout(performCheck, sleepTime)
+        })
+        .catch((err) => reject(err))
+    }
+
+    performCheck()
+  })
+}