@devp0nt/error0 1.0.0-next.51 → 1.0.0-next.53

package/src/plugins/flat-original.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'bun:test'
+import { Error0 } from '../index.js'
+import { flatOriginalPlugin } from './flat-original.js'
+
+describe('flatOriginalPlugin', () => {
+  it('without plugin original error comes to cause', () => {
+    const usualError = new Error('another error')
+    const error = Error0.from(usualError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.name).toBe('Error0')
+    expect(error.cause).not.toBeInstanceOf(Error0)
+    expect(error.cause).toBeInstanceOf(Error)
+    expect(error.cause).toBe(usualError)
+    expect((error.cause as any).name).toBe('Error')
+    expect(error.causes()).toEqual([error, usualError])
+  })
+
+  it('with plugin original error becomes error0 itself', () => {
+    const usualError = new Error('another error')
+    const AppError = Error0.use(flatOriginalPlugin())
+    const error = AppError.from(usualError)
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe(usualError.message)
+    expect(error.stack).toBe(usualError.stack)
+    expect(error.name).toBe('Error0')
+    expect(error.cause).toBeUndefined()
+  })
+
+  it('with plugin original error becomes error0 itself but keep it own causes', () => {
+    const causeError = new Error('cause error')
+    const usualError = new Error('another error', { cause: causeError })
+    const AppError = Error0.use(flatOriginalPlugin())
+    const error = AppError.from(usualError)
+    expect(error).toBeInstanceOf(AppError)
+    expect(error).toBeInstanceOf(Error0)
+    expect(error).toBeInstanceOf(Error)
+    expect(error.message).toBe(usualError.message)
+    expect(error.stack).toBe(usualError.stack)
+    expect(error.name).toBe('Error0')
+    expect(error.causes()).toEqual([error, causeError])
+  })
+})

package/src/plugins/flat-original.ts

@@ -0,0 +1,12 @@
+import { Error0 } from '../index.js'
+
+export const flatOriginalPlugin = ({ prefix }: { prefix?: string } = {}) => {
+  return Error0.plugin().adapt((error) => {
+    const cause = error.cause
+    if (cause instanceof Error && cause.constructor === Error) {
+      error.cause = cause.cause
+      error.message = `${prefix ?? ''}${cause.message}`
+      error.stack = cause.stack
+    }
+  })
+}

package/src/plugins/tags.test.ts

@@ -66,8 +66,6 @@ describe('tagsPlugin', () => {
 
     // @ts-expect-error - unknown tag is not part of allow-list
     error.hasTag('custom')
-    // @ts-expect-error - array checks require policy argument
-    error.hasTag(['api', 'db'])
     // @ts-expect-error - unsupported policy
     error.hasTag(['api', 'db'], 'all')
   })

package/src/plugins/tags.ts

@@ -5,21 +5,21 @@ export const tagsPlugin = <TTag extends string>({
   tags,
   strict = true,
 }: { isPublic?: boolean; tags?: TTag[] | readonly TTag[]; strict?: boolean } = {}) => {
-  function hasTag(error: Error0, tag: TTag): boolean
-  function hasTag(error: Error0, tag: TTag[], policy: 'every' | 'some'): boolean
-  function hasTag(error: Error0, tag: TTag | TTag[], policy?: 'every' | 'some'): boolean {
-    const tags = (error as any).tags as string[] | undefined
-    if (!tags) {
-      return false
-    }
-    if (Array.isArray(tag)) {
-      if (policy === 'every') {
-        return tag.every((item) => tags.includes(item))
-      }
-      return tag.some((item) => tags.includes(item))
-    }
-    return tags.includes(tag)
-  }
+  // function hasTag(error: Error0, tag: TTag): boolean
+  // function hasTag(error: Error0, tag: TTag[], policy: 'every' | 'some'): boolean
+  // function hasTag(error: Error0, tag: TTag | TTag[], policy?: 'every' | 'some'): boolean {
+  //   const tags = (error as any).tags as string[] | undefined
+  //   if (!tags) {
+  //     return false
+  //   }
+  //   if (Array.isArray(tag)) {
+  //     if (policy === 'every') {
+  //       return tag.every((item) => tags.includes(item))
+  //     }
+  //     return tag.some((item) => tags.includes(item))
+  //   }
+  //   return tags.includes(tag)
+  // }
   const isTag = (value: unknown): value is TTag =>
     typeof value === 'string' && (!tags || !strict || tags.includes(value as TTag))
   return Error0.plugin()
@@ -47,5 +47,17 @@ export const tagsPlugin = <TTag extends string>({
         return value.filter((item) => isTag(item))
       },
     })
-    .method('hasTag', hasTag)
+    .method('hasTag', (error, tag: TTag | TTag[], policy: 'every' | 'some' = 'every'): boolean => {
+      const tags = error.tags
+      if (!tags) {
+        return false
+      }
+      if (Array.isArray(tag)) {
+        if (policy === 'every') {
+          return tag.every((item) => tags.includes(item))
+        }
+        return tag.some((item) => tags.includes(item))
+      }
+      return tags.includes(tag)
+    })
 }