@orpc/shared 0.0.0-next.e9dc36e → 0.0.0-next.eae6003

package/src/error.ts

@@ -1,106 +0,0 @@
-import { ZodError, type ZodIssue } from 'zod'
-
-export const ORPC_ERROR_CODE_STATUSES = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_SUPPORTED: 405,
-  NOT_ACCEPTABLE: 406,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  UNPROCESSABLE_CONTENT: 422,
-  TOO_MANY_REQUESTS: 429,
-  CLIENT_CLOSED_REQUEST: 499,
-
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504,
-} as const
-
-export type ORPCErrorCode = keyof typeof ORPC_ERROR_CODE_STATUSES
-
-export class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
-  constructor(
-    public zz$oe: {
-      code: TCode
-      status?: number
-      message?: string
-      cause?: unknown
-    } & (undefined extends TData ? { data?: TData } : { data: TData }),
-  ) {
-    if (zz$oe.status && (zz$oe.status < 400 || zz$oe.status >= 600)) {
-      throw new Error('The ORPCError status code must be in the 400-599 range.')
-    }
-
-    super(zz$oe.message, { cause: zz$oe.cause })
-  }
-
-  get code(): TCode {
-    return this.zz$oe.code
-  }
-
-  get status(): number {
-    return this.zz$oe.status ?? ORPC_ERROR_CODE_STATUSES[this.code]
-  }
-
-  get data(): TData {
-    return this.zz$oe.data as TData
-  }
-
-  get issues(): ZodIssue[] | undefined {
-    if (this.code === 'BAD_REQUEST' && this.zz$oe.cause instanceof ZodError) {
-      return this.zz$oe.cause.issues
-    }
-
-    return undefined
-  }
-
-  toJSON(): {
-    code: TCode
-    status: number
-    message: string
-    data: TData
-    issues?: ZodIssue[]
-  } {
-    return {
-      code: this.code,
-      status: this.status,
-      message: this.message,
-      data: this.data,
-      issues: this.issues,
-    }
-  }
-
-  static fromJSON(json: unknown): ORPCError<ORPCErrorCode, any> | undefined {
-    if (
-      typeof json !== 'object'
-      || json === null
-      || !('code' in json)
-      || !Object.keys(ORPC_ERROR_CODE_STATUSES).find(key => json.code === key)
-      || !('status' in json)
-      || typeof json.status !== 'number'
-      || ('message' in json
-        && json.message !== undefined
-        && typeof json.message !== 'string')
-      || ('issues' in json
-        && json.issues !== undefined
-        && !Array.isArray(json.issues))
-    ) {
-      return undefined
-    }
-
-    return new ORPCError({
-      code: json.code as ORPCErrorCode,
-      status: json.status as number,
-      message: Reflect.get(json, 'message') as string,
-      data: Reflect.get(json, 'data') as any,
-      cause: 'issues' in json ? new ZodError(json.issues as any) : undefined,
-    })
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export * from './json'
-
-export * from './object'
-export * from './value'
-export { isPlainObject } from 'is-what'
-
-export { guard, mapEntries, mapValues, omit, trim } from 'radash'
-export type * from 'type-fest'

package/src/json.ts

@@ -1,11 +0,0 @@
-export function parseJSONSafely(text: string): unknown {
-  if (text === '')
-    return undefined
-
-  try {
-    return JSON.parse(text)
-  }
-  catch {
-    return text
-  }
-}

package/src/object.ts

@@ -1,79 +0,0 @@
-import { isPlainObject } from 'is-what'
-
-export type Segment = string | number
-
-export function set(
-  root: Readonly<Record<string, unknown> | unknown[]>,
-  segments: Readonly<Segment[]>,
-  value: unknown,
-): unknown {
-  const ref = { root }
-
-  let currentRef: any = ref
-  let preSegment: string | number = 'root'
-
-  for (const segment of segments) {
-    currentRef = currentRef[preSegment]
-    preSegment = segment
-  }
-
-  currentRef[preSegment] = value
-
-  return ref.root
-}
-
-export function get(
-  root: Readonly<Record<string, unknown> | unknown[]>,
-  segments: Readonly<Segment[]>,
-): unknown {
-  const ref = { root }
-
-  let currentRef: any = ref
-  let preSegment: string | number = 'root'
-
-  for (const segment of segments) {
-    if (
-      (typeof currentRef !== 'object' && typeof currentRef !== 'function')
-      || currentRef === null
-    ) {
-      return undefined
-    }
-
-    currentRef = currentRef[preSegment]
-    preSegment = segment
-  }
-
-  if (
-    (typeof currentRef !== 'object' && typeof currentRef !== 'function')
-    || currentRef === null
-  ) {
-    return undefined
-  }
-
-  return currentRef[preSegment]
-}
-
-export function findDeepMatches(
-  check: (value: unknown) => boolean,
-  payload: unknown,
-  segments: Segment[] = [],
-  maps: Segment[][] = [],
-  values: unknown[] = [],
-): { maps: Segment[][], values: unknown[] } {
-  if (check(payload)) {
-    maps.push(segments)
-    values.push(payload)
-  }
-  else if (Array.isArray(payload)) {
-    payload.forEach((v, i) => {
-      findDeepMatches(check, v, [...segments, i], maps, values)
-    })
-  }
-  else if (isPlainObject(payload)) {
-    for (const key in payload) {
-      findDeepMatches(check, payload[key], [...segments, key], maps, values)
-    }
-  }
-
-  return { maps, values }
-}

package/src/value.test-d.ts

@@ -1,22 +0,0 @@
-import { value, type Value } from './value'
-
-describe('value', () => {
-  it('types', () => {
-    let v: Value<number> = 42
-
-    v = async () => 42
-    v = () => 42
-
-    // @ts-expect-error - not a number
-    v = null
-
-    // @ts-expect-error - not a number
-    v = 'string'
-  })
-
-  it('function', () => {
-    expectTypeOf(value(Number(42))).toEqualTypeOf<Promise<number>>()
-    expectTypeOf(value(() => Number(42))).toEqualTypeOf<Promise<number>>()
-    expectTypeOf(value(async () => Number(42))).toEqualTypeOf<Promise<number>>()
-  })
-})

package/src/value.test.ts

@@ -1,17 +0,0 @@
-import { value } from './value'
-
-it('value', async () => {
-  expect(await value(42)).toBe(42)
-  expect(await value(() => 42)).toBe(42)
-  expect(await value(async () => 42)).toBe(42)
-
-  expect(await value(() => ({
-    then: (resolve: (value: number) => void) => resolve(42),
-  }))).toBe(42)
-
-  expect(await value(async () => ({
-    then: (resolve: (value: number) => void) => resolve(42),
-  }))).toBe(42)
-
-  expect(await value(() => ({ value: '42' }))).toEqual({ value: '42' })
-})

package/src/value.ts

@@ -1,12 +0,0 @@
-import type { Promisable } from 'type-fest'
-
-export type Value<T> = T | (() => Promisable<T>)
-
-export function value<T extends Value<any>>(value: T):
-Promise<T extends Value<infer U> ? U : never> {
-  if (typeof value === 'function') {
-    return value()
-  }
-
-  return value as any
-}