@brickflow/http 0.0.14 → 0.0.16

package/src/nuxt.ts

@@ -0,0 +1,355 @@
+import { onScopeDispose, shallowReactive, shallowRef } from 'vue'
+
+import { useLazyAsyncData, useState } from '#app'
+
+import type { GetConfig, HttpClient, HttpErrorGuard, HttpKey, HttpParam, HttpResponseData } from './http'
+
+import { createURL, hashData } from './utils'
+
+const DAY = 1000 * 60 * 60 * 24
+const DEFAULT_CHANNEL_NAME = 'http-tab-sync'
+const DEFAULT_TTL = DAY * 7
+export interface CreateUseHttpDependencies {
+  channelName?: string
+  getCache: () => null | UseHttpCache
+  getHttpClient: () => HttpClient
+  isDev?: () => boolean
+  isError?: HttpErrorGuard<unknown>
+  ttl?: number
+}
+
+export type HttpError = HttpErrorMap[keyof HttpErrorMap]
+export interface HttpErrorMap {}
+export type HttpSuccessData<TKey extends HttpKey = HttpKey> = Exclude<HttpResponseData<TKey>, HttpError>
+
+export interface UseHttpCache {
+  deleteKeysWithPart: (part: string) => Promise<void>
+  get: <T>(key: string) => Promise<null | UseHttpCacheEntry<T>>
+  set: <T>(key: string, value: T, ttl: number) => Promise<void>
+}
+
+export interface UseHttpCacheEntry<T> {
+  hash: string
+  value: T
+}
+
+export interface UseHttpFn {
+  <T extends HttpKey, P extends HttpParam>(options: UseHttpOptions<T, P>): Promise<UseHttpResult<T, P>>
+}
+
+export interface UseHttpOptions<T extends HttpKey, P extends HttpParam> {
+  effect?: UseHttpEffect<T, P>
+  initParams?: P
+  isError?: (payload: HttpResponseData<T>) => boolean
+  lazy?: true
+  mapParams?: (params?: P) => P
+  server?: boolean
+  url: T
+}
+
+export interface UseHttpResult<T extends HttpKey, P extends HttpParam> {
+  data: HttpSuccessData<T> | null
+  error: null | UseHttpError<T>
+  fetch: UseHttpFetch<P>
+  hasFirstData: boolean
+  hasFreshData: boolean
+  pending: boolean
+  pendingCache: boolean
+}
+
+type BroadcastMessage = {
+  data: unknown
+  fullUrl: string
+  params: HttpParam
+  type: 'STATE_UPDATE'
+}
+
+type UseHttpEffect<T extends HttpKey, P extends HttpParam> = (
+  data: HttpResponseData<T>,
+  config: UseHttpEffectConfig<P>,
+) => void
+type UseHttpEffectConfig<P extends HttpParam> = {
+  cached: boolean
+  params: P
+}
+type UseHttpError<T extends HttpKey> = Extract<HttpResponseData<T>, HttpError>
+
+type UseHttpFetch<P extends HttpParam> = (params?: P, opt?: { signal: AbortSignal }) => Promise<void>
+
+export function createUseHttp(dependencies: CreateUseHttpDependencies): UseHttpFn {
+  let channel: BroadcastChannel | null
+
+  const useHttp: UseHttpFn = async <T extends HttpKey, P extends HttpParam>(
+    options: UseHttpOptions<T, P>,
+  ): Promise<UseHttpResult<T, P>> => {
+    const mapParams = (params?: P): P => {
+      if (options.mapParams) {
+        return options.mapParams(params)
+      }
+
+      return params ?? ({} as P)
+    }
+    const effect = options.effect
+    const isError = createIsErrorGuard(options.isError, dependencies.isError)
+
+    const buildUrl = createURL
+    const initFullUrl = buildUrl(options.url, mapParams(options.initParams))
+    const httpClient = dependencies.getHttpClient()
+    const cache = import.meta.client ? (dependencies.getCache?.() ?? null) : null
+    let hasDataFromServer = false
+
+    const result = shallowReactive({
+      data: null as null | unknown,
+      error: null as null | unknown,
+      fetch: async (_params?: P, _opt?: { signal: AbortSignal }): Promise<void> => await undefined,
+      hasFirstData: false,
+      hasFreshData: false,
+      pending: true,
+      pendingCache: true,
+    })
+    const setError = (value: null | unknown): void => {
+      result.error = value
+    }
+    const setData = (value: null | unknown): void => {
+      result.data = value
+    }
+    const syncResult = (payload: HttpResponseData<T> | null | undefined): void => {
+      if (payload === null || payload === undefined) {
+        setData(null)
+        setError(null)
+        return
+      }
+
+      if (isError(payload)) {
+        setData(null)
+        setError(payload)
+        return
+      }
+
+      setData(payload)
+      setError(null)
+    }
+
+    const controller = new AbortController()
+    const serverData = useState<null | unknown>(`http-${initFullUrl}`, () => null)
+
+    if (options.server && import.meta.server) {
+      const paramsReactive = shallowRef(mapParams(options.initParams))
+      const ssr = await useLazyAsyncData(initFullUrl, async () => {
+        return await httpClient.get<T>(options.url, {
+          params: paramsReactive.value,
+        } as GetConfig<T>)
+      })
+
+      result.fetch = async (params?: P) => {
+        paramsReactive.value = mapParams(params)
+        await ssr.refresh()
+      }
+
+      serverData.value = ssr.data.value?.data ?? null
+      const serverPayload = serverData.value as HttpResponseData<T>
+      syncResult(serverPayload)
+
+      result.pending = false
+      result.pendingCache = false
+      result.hasFirstData = true
+      result.hasFreshData = true
+
+      if (serverData.value) {
+        effect?.(serverData.value as HttpResponseData<T>, {
+          cached: false,
+          params: mapParams(options.initParams),
+        })
+      }
+
+      if (result.data) {
+        hasDataFromServer = true
+      }
+    }
+
+    if (import.meta.client) {
+      channel = getChannel(dependencies.channelName ?? DEFAULT_CHANNEL_NAME, channel)
+      const fullUrlHistory: Record<string, true> = {}
+
+      function onMessage(event: MessageEvent<Partial<BroadcastMessage>>): void {
+        if (event.data.fullUrl && fullUrlHistory[event.data.fullUrl]) {
+          const eventPayload = event.data.data as HttpResponseData<T> | undefined
+
+          if (eventPayload) {
+            effect?.(eventPayload, {
+              cached: false,
+              params: event.data.params as P,
+            })
+          }
+
+          syncResult(eventPayload)
+
+          result.hasFirstData = true
+          result.hasFreshData = true
+        }
+      }
+
+      channel?.addEventListener('message', onMessage)
+
+      if (serverData.value) {
+        const clientServerPayload = serverData.value as HttpResponseData<T>
+        syncResult(clientServerPayload)
+        result.pending = false
+        result.pendingCache = false
+        result.hasFirstData = true
+        result.hasFreshData = true
+      }
+
+      const raceCondition: Record<string, number> = {}
+      const ttl = dependencies.ttl ?? DEFAULT_TTL
+
+      const runFetch = async (params?: P, fetchOpt?: { signal?: AbortSignal }): Promise<void> => {
+        const mappedParams = mapParams(params)
+        const fullUrl = buildUrl(options.url, mappedParams)
+        const fetchId = Date.now() + getRandom(0, 300)
+
+        if (raceCondition[fullUrl]) {
+          console.info('Race Condition affect', fullUrl)
+          return
+        }
+
+        raceCondition[fullUrl] = fetchId
+
+        try {
+          result.pending = true
+          result.pendingCache = true
+
+          const cachedFetch = cache && !dependencies.isDev?.() ? await cache.get<unknown>(fullUrl) : null
+
+          if (cachedFetch) {
+            const cachedPayload = cachedFetch.value as HttpResponseData<T>
+
+            effect?.(cachedPayload, {
+              cached: true,
+              params: mappedParams,
+            })
+
+            syncResult(cachedPayload)
+            result.hasFirstData = true
+
+            result.pendingCache = false
+          }
+
+          if (controller.signal.aborted || fetchOpt?.signal?.aborted) {
+            throw new DOMException('Aborted', 'AbortError')
+          }
+
+          const signalHttp = fetchOpt?.signal ? [controller.signal, fetchOpt.signal] : controller.signal
+          const response = await httpClient.get<T>(options.url, {
+            params: mappedParams,
+            signal: signalHttp,
+          } as GetConfig<T>)
+          const responsePayload = response.data as HttpResponseData<T>
+
+          effect?.(responsePayload, {
+            cached: false,
+            params: mappedParams,
+          })
+
+          if (isError(responsePayload)) {
+            syncResult(responsePayload)
+          } else {
+            syncResult(responsePayload)
+            const successData = responsePayload
+
+            fullUrlHistory[fullUrl] = true
+            channel?.postMessage({
+              data: normalizeBroadcastValue(successData),
+              fullUrl,
+              params: normalizeBroadcastValue(mappedParams),
+              type: 'STATE_UPDATE',
+            } satisfies BroadcastMessage)
+
+            if (cache) {
+              if (cachedFetch) {
+                const newHash = await hashData(responsePayload)
+                if (newHash !== cachedFetch.hash) {
+                  await cache.deleteKeysWithPart(options.url)
+                }
+              }
+
+              if (response.status === 200) {
+                await cache.set(fullUrl, successData, ttl)
+              }
+            }
+          }
+
+          result.hasFirstData = true
+          result.hasFreshData = true
+        } catch (error) {
+          console.error(error)
+        } finally {
+          if (raceCondition[fullUrl] === fetchId) {
+            delete raceCondition[fullUrl]
+          }
+
+          result.pending = false
+          result.pendingCache = false
+        }
+      }
+
+      result.fetch = runFetch
+
+      if (!hasDataFromServer && options.lazy !== true) {
+        runFetch(options.initParams)
+      }
+
+      onScopeDispose(() => {
+        channel?.removeEventListener('message', onMessage)
+        controller.abort(`Http Abort -> onScopeDispose ${options.url}`)
+
+        if (serverData.value) {
+          serverData.value = null
+        }
+      })
+    }
+
+    return result as UseHttpResult<T, P>
+  }
+
+  return useHttp
+}
+
+function createIsErrorGuard<TData>(
+  localGuard?: (payload: TData) => boolean,
+  globalGuard?: HttpErrorGuard<unknown>,
+): (payload: TData) => boolean {
+  if (localGuard) {
+    return localGuard
+  }
+
+  if (globalGuard) {
+    return globalGuard as (payload: TData) => boolean
+  }
+
+  return (): boolean => false
+}
+
+function getChannel(name: string, currentChannel?: BroadcastChannel | null): BroadcastChannel | null {
+  if (currentChannel) {
+    return currentChannel
+  }
+
+  if (import.meta.server || typeof BroadcastChannel !== 'function') {
+    return null
+  }
+
+  return new BroadcastChannel(name)
+}
+
+function getRandom(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+function normalizeBroadcastValue<T>(payload: T): T {
+  try {
+    return structuredClone(payload)
+  } catch {
+    return JSON.parse(JSON.stringify(payload)) as T
+  }
+}

package/src/utils.ts

@@ -0,0 +1,50 @@
+import type { HttpParam } from './http'
+
+export function createURL(url: string, params?: HttpParam): string {
+  const urlParams = new URLSearchParams()
+
+  Object.entries(params ?? {}).forEach(([key, value]) => {
+    if (value === undefined) {
+      return
+    }
+
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        urlParams.append(`${key}[]`, item)
+      })
+      return
+    }
+
+    urlParams.append(key, String(value))
+  })
+
+  const query = urlParams.size > 0 ? `?${urlParams}` : ''
+  return urlParams.size > 0 ? `${url}${query}` : url
+}
+
+export function fastDevHash(data: unknown): string {
+  const str = JSON.stringify(data)
+  let hash = 0
+
+  for (let i = 0; i < str.length; i++) {
+    const chr = str.charCodeAt(i)
+    hash = (hash << 5) - hash + chr
+    hash |= 0
+  }
+
+  return Math.abs(hash).toString(16)
+}
+
+export async function hashData(data: unknown): Promise<string> {
+  const subtle = globalThis.crypto?.subtle
+
+  if (subtle) {
+    const encoded = new TextEncoder().encode(JSON.stringify(data))
+    const buffer = await subtle.digest('SHA-1', encoded)
+    const array = Array.from(new Uint8Array(buffer))
+
+    return array.map((value) => value.toString(16).padStart(2, '0')).join('')
+  }
+
+  return fastDevHash(data)
+}

package/dist/module.d.mts

@@ -1,73 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-import { HttpRetryConfig } from '../dist/runtime/utils/shared.js';
-export { CreateHttpClientOptions, GetConfig, HttpBaseURL, HttpBaseURLResolver, HttpClient, HttpConfig, HttpErrorPayload, HttpParam, HttpPayload, HttpRequestContext, HttpRequestMiddleware, HttpResponse, HttpResponseMiddleware, HttpRetryConfig, HttpRuntimeConfig, PostConfig } from '../dist/runtime/utils/shared.js';
-export { createHttpClient } from '../dist/runtime/http/client.js';
-export { addHttpRequestMiddleware, addHttpResponseMiddleware, removeHttpRequestMiddleware, removeHttpResponseMiddleware } from '../dist/runtime/utils/middleware.js';
-export { HttpRouteBody, HttpRouteData, HttpRouteDefinition, HttpRouteError, HttpRouteMap, HttpRouteParams, ResolveHttpRoute, StrictTypedHttpClient, TypedGetConfig, TypedHttpClient, TypedHttpResponse, TypedPostConfig, createStrictHttpClient, createTypedHttpClient, defineHttpRoutes } from '../dist/runtime/utils/typed.js';
-
-interface ModuleOptions {
-    /**
-     * Base URL used by the injected Nuxt HTTP client.
-     *
-     * @default ''
-     */
-    baseURL?: string;
-    /**
-     * Enables client-side IndexedDB caching in `useHttp()`.
-     *
-     * @default true
-     */
-    cache?: boolean;
-    /**
-     * IndexedDB database name used for cached responses.
-     *
-     * @default 'smart-cache-v2'
-     */
-    cacheDbName?: 'smart-cache-v2';
-    /**
-     * IndexedDB store name used for cached responses.
-     *
-     * @default 'data'
-     */
-    cacheStoreName?: string;
-    /**
-     * Cache TTL in milliseconds.
-     *
-     * @default 604800000
-     */
-    cacheTtlMs?: number;
-    /**
-     * Adds `Client-Env: development` in dev mode.
-     *
-     * @default true
-     */
-    clientEnvHeader?: boolean;
-    /**
-     * Default headers merged into every request.
-     *
-     * @default {}
-     */
-    defaultHeaders?: Record<string, string>;
-    /**
-     * Disables IndexedDB cache when `import.meta.dev` is enabled.
-     *
-     * @default true
-     */
-    disableCacheInDev?: boolean;
-    /**
-     * Request timeout in milliseconds.
-     *
-     * @default 80000
-     */
-    requestTimeoutMs?: number;
-    /**
-     * Retry policy for GET requests on retryable responses and network failures.
-     *
-     * @default { delay: 300, retries: 3 }
-     */
-    retry?: HttpRetryConfig;
-}
-declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
-
-export { _default as default };
-export type { ModuleOptions };

package/dist/module.json

@@ -1,12 +0,0 @@
-{
-  "compatibility": {
-    "nuxt": ">=4.0.0"
-  },
-  "configKey": "brickflowHttp",
-  "name": "@brickflow/http",
-  "version": "0.0.14",
-  "builder": {
-    "@nuxt/module-builder": "1.0.2",
-    "unbuild": "3.6.1"
-  }
-}

package/dist/module.mjs

@@ -1,59 +0,0 @@
-import { defineNuxtModule, createResolver, addPlugin, addImportsDir } from '@nuxt/kit';
-export { createHttpClient } from '../dist/runtime/http/client.js';
-export { addHttpRequestMiddleware, addHttpResponseMiddleware, removeHttpRequestMiddleware, removeHttpResponseMiddleware } from '../dist/runtime/utils/middleware.js';
-export { createStrictHttpClient, createTypedHttpClient, defineHttpRoutes } from '../dist/runtime/utils/typed.js';
-
-const DAY = 1e3 * 60 * 60 * 24;
-const defaultRuntimeConfig = {
-  baseURL: "",
-  cache: true,
-  cacheDbName: "smart-cache-v2",
-  cacheStoreName: "data",
-  cacheTtlMs: DAY * 7,
-  clientEnvHeader: true,
-  defaultHeaders: {},
-  disableCacheInDev: true,
-  requestTimeoutMs: 8e4,
-  retry: {
-    delay: 300,
-    retries: 3
-  }
-};
-const module$1 = defineNuxtModule({
-  defaults: defaultRuntimeConfig,
-  meta: {
-    compatibility: {
-      nuxt: ">=4.0.0"
-    },
-    configKey: "brickflowHttp",
-    name: "@brickflow/http"
-  },
-  setup(options, nuxt) {
-    const resolver = createResolver(import.meta.url);
-    const currentConfig = nuxt.options.runtimeConfig.public.brickflowHttp ?? {};
-    nuxt.options.runtimeConfig.public.brickflowHttp = {
-      ...defaultRuntimeConfig,
-      ...currentConfig,
-      ...options,
-      defaultHeaders: {
-        ...defaultRuntimeConfig.defaultHeaders,
-        ...currentConfig.defaultHeaders ?? {},
-        ...options.defaultHeaders ?? {}
-      },
-      retry: {
-        ...defaultRuntimeConfig.retry,
-        ...currentConfig.retry ?? {},
-        ...options.retry ?? {}
-      }
-    };
-    addPlugin(resolver.resolve("./runtime/plugin"));
-    addImportsDir(resolver.resolve("./runtime/composables"));
-    nuxt.hook("prepare:types", ({ references }) => {
-      references.push({
-        path: resolver.resolve("./runtime/types.d.ts")
-      });
-    });
-  }
-});
-
-export { module$1 as default };

package/dist/runtime/composables/useHttp.d.ts

@@ -1,27 +0,0 @@
-import { type ShallowReactive } from 'vue';
-import type { HttpRouteData, HttpRouteError, HttpRouteMap, HttpRouteParams, ResolveHttpRoute } from '../utils/typed.js';
-import { type HttpErrorPayload, type HttpParam, type HttpPayload } from '../utils/shared.js';
-type UseHttpState<TData, TError extends HttpErrorPayload, TParams extends HttpParam> = ShallowReactive<{
-    data: null | TData;
-    error: null | TError;
-    fetch: (params?: TParams, opt?: {
-        signal: AbortSignal;
-    }) => Promise<void>;
-    hasFirstData: boolean;
-    hasFreshData: boolean;
-    pending: boolean;
-    pendingCache: boolean;
-}>;
-export declare function useHttp<TUrl extends Extract<keyof HttpRouteMap, string>>(options: {
-    effect?: (payload: HttpPayload<HttpRouteData<ResolveHttpRoute<HttpRouteMap, TUrl>>, HttpRouteError<ResolveHttpRoute<HttpRouteMap, TUrl>>>, config: {
-        cached: boolean;
-        params: HttpRouteParams<ResolveHttpRoute<HttpRouteMap, TUrl>>;
-    }) => undefined | void;
-    initParams?: HttpRouteParams<ResolveHttpRoute<HttpRouteMap, TUrl>>;
-    lazy?: true;
-    mapParams?: <TMapped extends HttpRouteParams<ResolveHttpRoute<HttpRouteMap, TUrl>>>(params?: TMapped) => TMapped;
-    server?: boolean;
-    url: TUrl;
-}): Promise<UseHttpState<HttpRouteData<ResolveHttpRoute<HttpRouteMap, TUrl>>, HttpRouteError<ResolveHttpRoute<HttpRouteMap, TUrl>>, HttpRouteParams<ResolveHttpRoute<HttpRouteMap, TUrl>>>>;
-export {};
-//# sourceMappingURL=useHttp.d.ts.map