@brickflow/http 0.0.14 → 0.0.16

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@brickflow/http",
-  "version": "0.0.14",
-  "type": "module",
-  "description": "brickflow HTTP Nuxt module.",
+  "version": "0.0.16",
+  "description": "Minimal HTTP transport and Nuxt state helpers for brickflow.",
+  "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
-  "main": "./dist/module.mjs",
-  "types": "./dist/module.d.mts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
-      "types": "./dist/module.d.mts",
-      "import": "./dist/module.mjs"
+      "types": "./src/index.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./nuxt": {
+      "types": "./src/nuxt.ts",
+      "development": "./src/nuxt.ts",
+      "import": "./dist/nuxt.mjs",
+      "default": "./dist/nuxt.mjs"
     }
   },
   "scripts": {
-    "build": "NODE_OPTIONS='--conditions=development' nuxt-module-build build",
-    "typecheck": "NODE_OPTIONS='--conditions=development' vue-tsc --project tsconfig.json --noEmit",
-    "lint": "pnpm run --if-present typecheck && eslint -v && NODE_ENV=deploy eslint --cache .",
+    "build": "rolldown -c build.config.ts && tsc --project tsconfig.build.json",
+    "typecheck": "NODE_OPTIONS='--conditions=development' tsc --project tsconfig.json --noEmit",
+    "lint": "pnpm typecheck && eslint -v && NODE_ENV=deploy eslint --cache .",
     "lint:fix": "pnpm exec eslint . --fix",
     "format": "pnpm exec prettier . --ignore-path ../../.prettierignore --write",
     "format:check": "pnpm exec prettier . --ignore-path ../../.prettierignore --check"
@@ -25,15 +35,17 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@nuxt/kit": "4.4.7"
+  },
   "devDependencies": {
     "@brickflow/lint": "workspace:*",
     "@brickflow/prettier": "workspace:*",
-    "@nuxt/kit": "4.4.6",
-    "@nuxt/module-builder": "1.0.2",
-    "nuxt": "4.4.6",
-    "vue": "3.5.35",
-    "vue-tsc": "3.3.2"
+    "rolldown": "1.1.0",
+    "vue-tsc": "3.3.4"
   },
-  "author": "",
-  "license": "ISC"
+  "peerDependencies": {
+    "nuxt": ">=3",
+    "vue": ">=3"
+  }
 }

package/src/app.d.ts

@@ -0,0 +1,11 @@
+declare module '#app' {
+  export * from 'nuxt/app'
+}
+
+interface ImportMeta {
+  browser: boolean
+  client: boolean
+  dev: boolean
+  server: boolean
+  test: boolean
+}

package/src/create-get.ts

@@ -0,0 +1,43 @@
+import type { HttpClient, HttpKey, HttpParam } from './http'
+import type { UseHttpFn, UseHttpOptions, UseHttpResult } from './nuxt'
+
+export type CreateGetOptions<T extends HttpKey, P extends HttpParam> = Omit<UseHttpOptions<T, P>, 'url'>
+
+export type CreateGetPayload<T extends HttpKey, P extends HttpParam> = Pick<
+  UseHttpOptions<T, P>,
+  'effect' | 'isError' | 'mapParams'
+>
+
+export type CreateGetResult<T extends HttpKey, P extends HttpParam> = UseHttpResult<T, P>
+
+export function createUseCase<D>() {
+  return <T>(
+    callback: (payload: D & { httpClient: HttpClient }) => T,
+  ): ((payload: D & { httpClient: HttpClient }) => T) => callback
+}
+
+export function defineGet(useHttp: UseHttpFn) {
+  return function withParams<P extends HttpParam>() {
+    return function withUrl<T extends HttpKey>(
+      url: T,
+      payload?: CreateGetPayload<T, P>,
+    ): (options?: CreateGetOptions<T, P>) => Promise<CreateGetResult<T, P>> {
+      return async function request(options: CreateGetOptions<T, P> = {}): Promise<CreateGetResult<T, P>> {
+        const result = await useHttp({
+          ...options,
+          effect: (...args) => {
+            const [data, config] = args
+
+            payload?.effect?.(data, config)
+            options?.effect?.(data, config)
+          },
+          isError: options.isError ?? payload?.isError,
+          mapParams: options.mapParams ?? payload?.mapParams,
+          url,
+        })
+
+        return result
+      }
+    }
+  }
+}

package/src/http.ts

@@ -0,0 +1,286 @@
+export interface CreateHttpOptions {
+  arrayMode?: HttpArrayMode
+  baseURL: string
+  fetch?: typeof fetch
+  headers?: (() => HttpHeaders) | HttpHeaders
+  onResponse?: (response: HttpAnyResponse) => Promise<void> | void
+  timeout?: number
+}
+
+export type GetConfig<TKey extends HttpKey = HttpKey> = HttpConfigFull<TKey> & {
+  retry?: {
+    delay?: number
+    retries?: number
+  }
+}
+
+export type HttpAnyResponse = HttpResponse<HttpResponseData<HttpKey>, HttpKey, HttpConfigFull<HttpKey>>
+
+export type HttpArrayMode = 'json' | 'repeat'
+
+export type HttpClient = {
+  get: <T extends HttpKey, TConfig extends GetConfig<T> = GetConfig<T>>(
+    url: T,
+    config?: TConfig,
+  ) => Promise<HttpResponse<HttpResponseData<T>, T, TConfig>>
+  post: <T extends HttpKey, TConfig extends PostConfig<T> = PostConfig<T>>(
+    url: T,
+    data?: FormData | Record<string, unknown>,
+    config?: TConfig,
+  ) => Promise<HttpResponse<HttpResponseData<T>, T, TConfig>>
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface HttpConfig<TKey extends HttpKey = HttpKey> {}
+export interface HttpEndpoint {}
+export type HttpErrorGuard<TData = unknown, TError extends TData = TData> = (payload: TData) => payload is TError
+
+export type HttpKey = Extract<keyof HttpSchema, string>
+export type HttpParam = Record<string, boolean | number | string | string[] | undefined>
+
+export interface HttpResponse<
+  T = unknown,
+  TKey extends HttpKey = HttpKey,
+  TConfig extends HttpConfigFull<TKey> = HttpConfigFull<TKey>,
+> {
+  config: HttpResponseConfig<TKey, TConfig>
+  data: T
+  status: number
+}
+export type HttpResponseConfig<
+  TKey extends HttpKey = HttpKey,
+  TConfig extends HttpConfig<TKey> = HttpConfig<TKey>,
+> = Omit<TConfig, 'signal'> & { url: string }
+
+export type HttpResponseData<TKey extends HttpKey = HttpKey> = HttpSchema[TKey]
+
+export type PostConfig<TKey extends HttpKey = HttpKey> = HttpConfigFull<TKey>
+
+type HttpConfigFull<TKey extends HttpKey = HttpKey> = HttpConfig<TKey> & {
+  params?: HttpParam
+  signal?: AbortSignal | AbortSignal[]
+}
+
+type HttpHeaders = Record<string, string | undefined>
+
+type HttpSchema = keyof HttpEndpoint extends never ? Record<string, unknown> : HttpEndpoint
+
+export function createHttp(options: CreateHttpOptions): HttpClient {
+  const arrayMode = options.arrayMode ?? 'json'
+  const clientFetch = options.fetch ?? fetch
+  const timeout = options.timeout ?? 80000
+
+  return {
+    get<T extends HttpKey, TConfig extends GetConfig<T> = GetConfig<T>>(url: T, config?: TConfig) {
+      const requestConfig = (config ?? {}) as TConfig
+      const requestUrl = `${joinUrl(options.baseURL, url)}${toQueryString(requestConfig.params, arrayMode)}`
+      const { delay = 300, retries = 3 } = requestConfig.retry ?? {}
+
+      const attemptRequest = async (attempt: number): Promise<HttpResponse<HttpResponseData<T>, T, TConfig>> => {
+        try {
+          const result = await clientFetch(requestUrl, {
+            credentials: 'include',
+            headers: resolveHeaders(options.headers),
+            method: 'GET',
+            signal: createSignal(requestConfig.signal, timeout),
+          })
+
+          const parsedResult = await result.json()
+          const response: HttpResponse<HttpResponseData<T>, T, TConfig> = {
+            config: createResponseConfig<T, TConfig>(joinUrl(options.baseURL, url), requestConfig),
+            data: parsedResult,
+            status: result.status,
+          }
+
+          if (!result.ok && isRetryableStatus(result.status) && attempt < retries) {
+            await wait(getRetryDelay(attempt, delay))
+            return attemptRequest(attempt + 1)
+          }
+
+          await options.onResponse?.(response as HttpAnyResponse)
+          return response
+        } catch (err) {
+          if (isAbortError(err) || attempt >= retries) {
+            throw err
+          }
+
+          await wait(getRetryDelay(attempt, delay))
+          return attemptRequest(attempt + 1)
+        }
+      }
+
+      return attemptRequest(0)
+    },
+    async post<T extends HttpKey, TConfig extends PostConfig<T> = PostConfig<T>>(
+      url: T,
+      data?: FormData | Record<string, unknown>,
+      config?: TConfig,
+    ) {
+      const requestConfig = (config ?? {}) as TConfig
+      const isForm = isFormData(data)
+      const requestUrl = `${joinUrl(options.baseURL, url)}${toQueryString(requestConfig.params, arrayMode)}`
+      const response = await clientFetch(requestUrl, {
+        body: isForm || data === undefined ? data : JSON.stringify(data),
+        credentials: 'include',
+        headers: resolveHeaders(
+          options.headers,
+          data !== undefined && !isForm ? { 'Content-Type': 'application/json' } : undefined,
+        ),
+        method: 'POST',
+        signal: createSignal(requestConfig.signal, timeout),
+      })
+
+      let parsedResult: Awaited<ReturnType<typeof response.json>> = {}
+      try {
+        parsedResult = await response.json()
+      } catch {
+        parsedResult = {}
+      }
+
+      const parsedResponse: HttpResponse<HttpResponseData<T>, T, TConfig> = {
+        config: createResponseConfig<T, TConfig>(joinUrl(options.baseURL, url), requestConfig),
+        data: parsedResult,
+        status: response.status,
+      }
+
+      await options.onResponse?.(parsedResponse as HttpAnyResponse)
+      return parsedResponse
+    },
+  }
+}
+
+function createAnySignal(signals: AbortSignal[]): AbortSignal {
+  if (typeof AbortSignal?.any === 'function') {
+    return AbortSignal.any(signals)
+  }
+
+  const controller = new AbortController()
+
+  signals.filter(Boolean).forEach((signal) => {
+    signal.addEventListener('abort', () => controller.abort(), { once: true })
+  })
+
+  return controller.signal
+}
+
+function createResponseConfig<TKey extends HttpKey, TConfig extends HttpConfigFull<TKey>>(
+  url: string,
+  config: TConfig,
+): HttpResponseConfig<TKey, TConfig> {
+  const responseConfig = { ...config } as Record<string, unknown>
+  delete responseConfig.signal
+
+  return {
+    ...responseConfig,
+    url,
+  } as HttpResponseConfig<TKey, TConfig>
+}
+
+function createSignal(signal: AbortSignal | AbortSignal[] | undefined, timeout: number): AbortSignal {
+  const timeoutSignal = createTimeoutSignal(timeout)
+
+  if (Array.isArray(signal)) {
+    return createAnySignal([...signal, timeoutSignal])
+  }
+
+  if (signal) {
+    return createAnySignal([signal, timeoutSignal])
+  }
+
+  return timeoutSignal
+}
+
+function createTimeoutSignal(ms: number): AbortSignal {
+  if (typeof AbortSignal?.timeout === 'function') {
+    return AbortSignal.timeout(ms)
+  }
+
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), ms)
+
+  controller.signal.addEventListener('abort', () => clearTimeout(timeoutId), {
+    once: true,
+  })
+
+  return controller.signal
+}
+
+function getRetryDelay(attempt: number, delay: number): number {
+  return delay * 2 ** attempt
+}
+
+function isAbortError(err: unknown): boolean {
+  return err instanceof DOMException && err.name === 'AbortError'
+}
+
+function isFormData(value: FormData | Record<string, unknown> | undefined): value is FormData {
+  return typeof FormData !== 'undefined' && value instanceof FormData
+}
+
+function isRetryableStatus(status: number): boolean {
+  return status >= 500 || status === 429
+}
+
+function joinUrl(baseURL: string, url: string): string {
+  const normalizedBase = baseURL.endsWith('/') ? baseURL.slice(0, -1) : baseURL
+  const normalizedUrl = url.startsWith('/') ? url.slice(1) : url
+
+  return `${normalizedBase}/${normalizedUrl}`
+}
+
+function resolveHeaders(
+  value: CreateHttpOptions['headers'],
+  extraHeaders?: Record<string, string>,
+): Record<string, string> {
+  const headers = typeof value === 'function' ? value() : value
+
+  return Object.entries({
+    ...headers,
+    ...extraHeaders,
+  }).reduce<Record<string, string>>((acc, [key, headerValue]) => {
+    if (typeof headerValue === 'string') {
+      acc[key] = headerValue
+    }
+
+    return acc
+  }, {})
+}
+
+function serializeQueryValue(
+  urlParams: URLSearchParams,
+  key: string,
+  value: HttpParam[string],
+  arrayMode: HttpArrayMode,
+): void {
+  if (value === undefined) {
+    return
+  }
+
+  if (Array.isArray(value)) {
+    if (arrayMode === 'json') {
+      urlParams.append(key, JSON.stringify(value))
+      return
+    }
+
+    value.forEach((item) => {
+      urlParams.append(`${key}[]`, item)
+    })
+    return
+  }
+
+  urlParams.append(key, String(value))
+}
+
+function toQueryString(params?: HttpParam, arrayMode: HttpArrayMode = 'json'): string {
+  const urlParams = new URLSearchParams()
+
+  Object.entries(params ?? {}).forEach(([key, value]) => {
+    serializeQueryValue(urlParams, key, value, arrayMode)
+  })
+
+  return urlParams.size > 0 ? `?${urlParams}` : ''
+}
+
+function wait(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './create-get'
+export * from './http'
+export * from './nuxt'