@cluesurf/kink 1.0.8 → 1.2.2

package/code/base/index.ts

@@ -0,0 +1,223 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { CustomError } from 'ts-custom-error'
+
+export type BaseHook<T extends any = any> = (
+  take?: T,
+) => KinkMeshBase & Link
+
+export type FillHook<T extends any = any, U extends any = any> = (
+  take?: T,
+  load?: U,
+) => Link
+
+export type KinkMesh = {
+  code: string
+  form: string
+  host: string
+  link?: Link
+  note: string
+  // HTTP code
+  siteCode?: number
+  take?: Link
+  time: string
+}
+
+export type KinkMeshBase = {
+  code: number
+  note: string
+}
+
+export type Link = Record<string, unknown>
+
+const base: Record<string, BaseHook> = {}
+const load: Record<string, LoadHook> = {}
+const fill: Record<string, FillHook> = {}
+const code: Record<string, (code: number) => string> = {}
+
+let timeHook: TimeHook = (time: number) => String(time)
+
+export type LoadHook<T extends any = any> = (take?: T) => Link
+
+export default class Kink extends CustomError {
+  form: string
+
+  host: string
+
+  code: string
+
+  note: string
+
+  link: Link
+
+  siteCode?: number
+
+  take?: Link
+
+  time: string
+
+  static base = (host: string, form: string, hook: BaseHook) => {
+    base[`${host}:${form}`] = hook
+    return Kink
+  }
+
+  static code = (host: string, hook: (code: number) => string) => {
+    code[host] = hook
+    return Kink
+  }
+
+  static load = (host: string, form: string, hook: LoadHook) => {
+    load[`${host}:${form}`] = hook
+    return Kink
+  }
+
+  static fill = (host: string, form: string, hook: FillHook) => {
+    fill[`${host}:${form}`] = hook
+    return Kink
+  }
+
+  static time = (hook: TimeHook) => {
+    timeHook = hook
+    return Kink
+  }
+
+  static makeTime = (time: number) => {
+    return timeHook(time)
+  }
+
+  static make = (host: string, form: string, take?: any) => {
+    const time = Kink.makeTime(Date.now())
+    const hook = base[`${host}:${form}`]
+    if (!hook) {
+      throw new Error(`Missing ${host}:${form} in Kink.base`)
+    }
+    const hookLink = hook(take) as KinkMeshBase & Link
+    const kink = new Kink({
+      ...hookLink,
+      code: Kink.makeCode(host, hookLink.code),
+      form,
+      host,
+      take: take as Link,
+      time,
+    })
+
+    Kink.saveLoad(kink, take)
+
+    return kink
+  }
+
+  static saveLoad = (kink: Kink, take?: any) => {
+    const hook = load[`${kink.host}:${kink.form}`]
+    if (!hook) {
+      // throw new Error(`Missing ${kink.host}:${kink.form} in Kink.load`)
+      return
+    }
+    kink.link = hook(take)
+  }
+
+  static saveFill = (kink: Kink) => {
+    const hook = fill[`${kink.host}:${kink.form}`]
+    if (!hook) {
+      // throw new Error(`Missing ${kink.host}:${kink.form} in Kink.fill`)
+      return
+    }
+    kink.link = hook(kink.take, kink.link)
+  }
+
+  static makeCode = (host: string, codeLink: number) => {
+    const hook = code[host]
+    if (!hook) {
+      return codeLink.toString()
+    }
+    return hook(codeLink)
+  }
+
+  static makeBase = (
+    kink: Error,
+    {
+      siteCode,
+      list = false,
+    }: { list?: boolean; siteCode?: number } = {},
+  ) => {
+    const time = Kink.makeTime(Date.now())
+    return new Kink({
+      code:
+        'code' in kink
+          ? typeof kink.code === 'string'
+            ? kink.code
+            : typeof kink.code === 'number'
+            ? Kink.makeCode('system', kink.code)
+            : '0000'
+          : '0000',
+      form: 'system_error',
+      host: 'system',
+      // list: stack ? kink.stack?.split('\n') ?? [] : [],
+      note: kink.message,
+      siteCode,
+      time,
+    })
+  }
+
+  constructor({
+    siteCode,
+    host,
+    note,
+    form,
+    take,
+    link = {},
+    code,
+    time,
+  }: KinkMesh) {
+    super(note)
+
+    Object.defineProperty(this, 'name', {
+      enumerable: false,
+      value: '',
+      writable: true,
+    })
+
+    Object.defineProperty(this, 'take', {
+      enumerable: false,
+      value: take,
+      writable: true,
+    })
+
+    this.time = time
+    this.host = host
+    this.form = form
+    this.code = code
+    this.note = note
+    this.link = link
+    this.take = take
+    this.siteCode = siteCode
+  }
+
+  toJSON(): KinkMesh {
+    return {
+      code: this.code,
+      form: this.form,
+      host: this.host,
+      link: this.link,
+      note: this.note,
+      time: this.time,
+    }
+  }
+}
+
+export type TimeHook = (time: number) => string
+
+// eslint-disable-next-line sort-exports/sort-exports
+export class KinkList extends Kink {
+  list: Array<Kink>
+
+  constructor(list: Array<Kink>) {
+    const time = Kink.makeTime(Date.now())
+    super({
+      code: Kink.makeCode('@cluesurf/kink', 0),
+      form: 'list',
+      host: '@cluesurf/kink',
+      note: 'A set of errors occurred.',
+      time,
+    })
+    this.list = list
+  }
+}

package/code/index.ts

@@ -0,0 +1,7 @@
+import Kink from './base'
+
+export * from './base'
+export * from './site'
+export * from './tree'
+
+export default Kink

package/code/site/index.ts

@@ -0,0 +1,92 @@
+import Kink, { KinkList } from '../base'
+import { z } from 'zod'
+import _ from 'lodash'
+import kink, { host } from './kink'
+import { makeKinkText } from '../tree'
+
+export function isZodError<I>(
+  input: any,
+): input is z.SafeParseError<I> {
+  return Boolean(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    input && !input.success && 'error' in input,
+  )
+}
+
+export function loadKink(error: any) {
+  const kink = loadKinkList(error)
+
+  if (kink instanceof KinkList) {
+    if (kink?.list.length === 1) {
+      return kink.list[0]
+    }
+  }
+
+  return kink
+}
+
+export function loadKinkList(error: any) {
+  if (error instanceof z.ZodError) {
+    return loadZodErrorJSON(error)
+  } else {
+    if (error instanceof KinkList) {
+      error.list.forEach(error => {
+        Kink.saveFill(error)
+      })
+      return error
+    } else if (error instanceof Kink) {
+      Kink.saveFill(error)
+      return error
+    } else if (error instanceof Error) {
+      return Kink.makeBase(error, { siteCode: 500 })
+    } else {
+      return Kink.makeBase(new Error(error as string), {
+        siteCode: 500,
+      })
+    }
+  }
+}
+
+export function loadZodErrorJSON(error: z.ZodError) {
+  return new KinkList(
+    error.issues.map(error => {
+      // ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+      switch (error.code) {
+        case z.ZodIssueCode.invalid_type:
+          return kink(
+            'form_fail',
+            {
+              have: error.received,
+              link: error.path.map(String),
+              message: error.message,
+              need: error.expected,
+            },
+            406,
+          )
+        case z.ZodIssueCode.unrecognized_keys:
+          return kink(
+            'form_link_fail',
+            {
+              link: error.path,
+              list: error.keys,
+              message: error.message,
+            },
+            406,
+          )
+        default: {
+          const kink = new Kink({
+            code: Kink.makeCode(host, 0),
+            form: 'z.ZodError',
+            host: host,
+            note: error.message,
+            time: Kink.makeTime(Date.now()),
+          })
+          kink.siteCode = 406
+          return kink
+        }
+      }
+    }),
+  )
+}
+
+export { default } from './make'

package/code/site/kink.ts

@@ -0,0 +1,97 @@
+import Kink from '~/code/base'
+
+export const host = '@cluesurf/kink'
+
+type BaseZodError = {
+  link: Array<string | number>
+  message: string
+}
+
+type Base = {
+  call_fail: {
+    take: {}
+  }
+  call_time_meet: {
+    take: {
+      link: string
+    }
+    // base: {
+    //   url: string
+    // }
+    // fill: {
+    //   url: string
+    // }
+  }
+  form_fail: {
+    take: BaseZodError & {
+      have: string
+      link: Array<string>
+      need: string
+    }
+  }
+  form_link_fail: {
+    take: BaseZodError & {
+      list: Array<string>
+    }
+  }
+}
+
+type Name = keyof Base
+
+let CODE_INDEX = 1
+
+const CODE = {
+  call_fail: CODE_INDEX++,
+  call_time_meet: CODE_INDEX++,
+  form_fail: CODE_INDEX++,
+  form_link_fail: CODE_INDEX++,
+}
+
+Kink.code(host, (code: number) => code.toString(16).padStart(4, '0'))
+
+Kink.base(
+  host,
+  'call_time_meet',
+  (take: Base['call_time_meet']['take']) => ({
+    code: CODE.call_time_meet,
+    link: take.link,
+    note: 'Request timeout.',
+  }),
+)
+
+Kink.base(host, 'call_fail', () => ({
+  code: CODE.call_fail,
+  note: 'System unable to make request currently.',
+}))
+
+Kink.base(host, 'form_fail', (take: Base['form_fail']['take']) => ({
+  code: CODE.form_fail,
+  have: take.have,
+  hint: take.message,
+  link: take.link,
+  need: take.need,
+  note: 'Invalid link type.',
+}))
+
+// https://github.com/colinhacks/zod/blob/master/ERROR_HANDLING.md
+Kink.base(
+  host,
+  'form_link_fail',
+  (take: Base['form_link_fail']['take']) => ({
+    code: CODE.form_link_fail,
+    hint: take.message,
+    link: take.link,
+    list: take.list,
+    note: 'Unrecognized keys in object.',
+  }),
+)
+
+export default function makeBase<N extends Name>(
+  form: N,
+  link?: Base[N]['take'],
+  siteCode?: number,
+) {
+  const kink = Kink.make(host, form, link)
+  kink.siteCode = siteCode
+  return kink
+}

package/code/site/make.ts

@@ -0,0 +1,17 @@
+import { KinkList } from '../base'
+import { loadKink } from '.'
+import { makeKinkText } from '../tree'
+
+export default function makeSiteKinkText(error: any) {
+  const kink = loadKink(error)
+  const text: Array<string> = []
+  if (kink instanceof KinkList) {
+    text.push(makeKinkText(kink))
+    kink.list.forEach(kink => {
+      text.push(makeKinkText(kink))
+    })
+  } else if (kink) {
+    text.push(makeKinkText(kink))
+  }
+  return text.join('\n')
+}

package/code/site/test.ts

@@ -0,0 +1,35 @@
+import Kink from '~/code/base'
+import fs from 'fs'
+import makeSiteKinkText from '.'
+
+const host = '@cluesurf/kink'
+
+type Base = {
+  syntax_error: {}
+}
+
+type Name = keyof Base
+
+Kink.base(host, 'syntax_error', () => ({
+  code: 1,
+  note: 'Syntax error',
+}))
+
+Kink.code(host, (code: number) => code.toString(16).padStart(4, '0'))
+
+export default function kink<N extends Name>(form: N, link?: Base[N]) {
+  return Kink.make(host, form, link)
+}
+
+// https://nodejs.org/api/errors.html
+process.on('uncaughtException', err => {
+  console.log(makeSiteKinkText(err))
+})
+
+setTimeout(() => {
+  throw kink('syntax_error')
+})
+
+setTimeout(() => {
+  fs.readFileSync('.')
+})

package/code/tree/browser.ts

@@ -0,0 +1,20 @@
+import Kink from '~/code/base'
+import makeText from './make'
+
+export * from './make'
+
+export function makeBaseKinkText(kink: Error): string {
+  return makeText({ ...Kink.makeBase(kink), list: [] })
+}
+
+export function makeKinkText(kink: Kink): string {
+  return makeText({
+    code: kink.code,
+    host: kink.host,
+    list: kink.stack?.split('\n') ?? [],
+    note: kink.note,
+    time: kink.time,
+  })
+}
+
+export { makeText }

package/code/tree/index.ts

@@ -0,0 +1 @@
+export * from './node'