@brickflow/http 0.0.14 → 0.0.15

package/package.json

@@ -1,23 +1,32 @@
 {
   "name": "@brickflow/http",
-  "version": "0.0.14",
-  "type": "module",
-  "description": "brickflow HTTP Nuxt module.",
+  "version": "0.0.15",
+  "description": "Minimal HTTP transport and Nuxt state helpers for brickflow.",
+  "sideEffects": false,
   "files": [
     "dist"
   ],
-  "main": "./dist/module.mjs",
-  "types": "./dist/module.d.mts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/module.d.mts",
-      "import": "./dist/module.mjs"
+      "types": "./dist/index.d.ts",
+      "development": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./nuxt": {
+      "types": "./dist/nuxt.d.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 run --if-present typecheck",
     "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 +34,17 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@nuxt/kit": "3.21.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",
+    "rolldown": "1.0.3",
     "vue-tsc": "3.3.2"
   },
-  "author": "",
-  "license": "ISC"
+  "peerDependencies": {
+    "nuxt": ">=3",
+    "vue": ">=3"
+  }
 }

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

package/dist/runtime/composables/useHttp.js

@@ -1,197 +0,0 @@
-import { useLazyAsyncData, useNuxtApp, useRuntimeConfig, useState } from "nuxt/app";
-import { onScopeDispose, shallowReactive, shallowRef } from "vue";
-import { dbDeleteKeysWithPart, dbGet, dbSafeSet, getRandom, hashData } from "../utils/index.js";
-import {
-  createHttpUrl,
-  createNetworkError,
-  isHttpErrorPayload
-} from "../utils/shared.js";
-const CHANNEL_NAME = "brickflow-http-tab-sync";
-let channel;
-export async function useHttp(options) {
-  const app = useNuxtApp();
-  const runtimeConfig = useRuntimeConfig();
-  const httpConfig = runtimeConfig.public.brickflowHttp;
-  const mapParams = (params) => {
-    if (options.mapParams) {
-      return options.mapParams(params ?? {});
-    }
-    return params ?? {};
-  };
-  const cacheEnabled = httpConfig.cache && !(httpConfig.disableCacheInDev && import.meta.dev);
-  const initFullUrl = createHttpUrl(options.url, mapParams(options.initParams));
-  let hasDataFromServer = false;
-  const result = shallowReactive({
-    data: null,
-    error: null,
-    fetch: async () => await void 0,
-    hasFirstData: false,
-    hasFreshData: false,
-    pending: true,
-    pendingCache: true
-  });
-  const controller = new AbortController();
-  const serverData = useState(`http:${initFullUrl}`, () => null);
-  if (options.server && import.meta.server) {
-    const paramsReactive = shallowRef(mapParams(options.initParams));
-    const ssr = await useLazyAsyncData(initFullUrl, async () => {
-      return await app.$http.get(options.url, {
-        params: paramsReactive.value
-      });
-    });
-    result.fetch = async (params) => {
-      paramsReactive.value = mapParams(params);
-      await ssr.refresh();
-    };
-    const payload = ssr.data.value?.data ?? null;
-    serverData.value = payload;
-    if (payload === null) {
-      result.pending = false;
-      result.pendingCache = false;
-    } else {
-      applyPayload(payload, result);
-      result.hasFirstData = true;
-      result.hasFreshData = true;
-      result.pending = false;
-      result.pendingCache = false;
-      options.effect?.(payload, {
-        cached: false,
-        params: mapParams(options.initParams)
-      });
-      if (!isHttpErrorPayload(payload)) {
-        hasDataFromServer = true;
-      }
-    }
-  }
-  if (import.meta.client) {
-    let onMessage = function(event) {
-      if (!event.data.fullUrl || !fullUrlHistory[event.data.fullUrl] || event.data.data === void 0) {
-        return;
-      }
-      const payload = event.data.data;
-      applyPayload(payload, result);
-      result.hasFirstData = true;
-      result.hasFreshData = true;
-      options.effect?.(payload, {
-        cached: false,
-        params: event.data.params ?? mapParams()
-      });
-    };
-    const fullUrlHistory = {};
-    const clientChannel = getChannel();
-    clientChannel?.addEventListener("message", onMessage);
-    if (serverData.value !== null) {
-      applyPayload(serverData.value, result);
-      result.pending = false;
-      result.pendingCache = false;
-      result.hasFirstData = true;
-      result.hasFreshData = true;
-    }
-    const raceCondition = {};
-    const runFetch = async (params, fetchOpt) => {
-      const mappedParams = mapParams(params);
-      const fullUrl = createHttpUrl(options.url, mappedParams);
-      const fetchId = Date.now() + getRandom(0, 300);
-      if (raceCondition[fullUrl]) {
-        return;
-      }
-      raceCondition[fullUrl] = fetchId;
-      try {
-        result.pending = true;
-        result.pendingCache = true;
-        const cachedFetch = cacheEnabled && httpConfig.cacheDbName && httpConfig.cacheStoreName ? await dbGet(fullUrl, "smart-cache-v2", httpConfig.cacheStoreName) : null;
-        if (cachedFetch) {
-          applyPayload(cachedFetch.value, result);
-          result.hasFirstData = true;
-          result.pendingCache = false;
-          options.effect?.(cachedFetch.value, {
-            cached: true,
-            params: mappedParams
-          });
-        }
-        if (controller.signal.aborted || fetchOpt?.signal?.aborted) {
-          throw new DOMException("Aborted", "AbortError");
-        }
-        const signal = fetchOpt?.signal ? [controller.signal, fetchOpt.signal] : controller.signal;
-        const response = await app.$http.get(options.url, {
-          params: mappedParams,
-          signal
-        });
-        applyPayload(response.data, result);
-        result.hasFirstData = true;
-        result.hasFreshData = true;
-        fullUrlHistory[fullUrl] = true;
-        clientChannel?.postMessage({
-          data: normalizeBroadcastValue(response.data),
-          fullUrl,
-          params: normalizeBroadcastValue(mappedParams),
-          type: "STATE_UPDATE"
-        });
-        options.effect?.(response.data, {
-          cached: false,
-          params: mappedParams
-        });
-        if (cacheEnabled && response.status === 200) {
-          if (cachedFetch !== null) {
-            const currentHash = await hashData(response.data);
-            if (currentHash !== cachedFetch.hash) {
-              await dbDeleteKeysWithPart(options.url, "smart-cache-v2", httpConfig.cacheStoreName);
-            }
-          }
-          await dbSafeSet(
-            fullUrl,
-            response.data,
-            "smart-cache-v2",
-            httpConfig.cacheStoreName,
-            httpConfig.cacheTtlMs
-          );
-        }
-      } catch (error) {
-        if (!isHttpErrorPayload(result.error)) {
-          result.error = createNetworkError(error);
-        }
-      } finally {
-        if (raceCondition[fullUrl] === fetchId) {
-          delete raceCondition[fullUrl];
-        }
-        result.pending = false;
-        result.pendingCache = false;
-      }
-    };
-    result.fetch = runFetch;
-    if (!hasDataFromServer && options.lazy !== true) {
-      await runFetch(options.initParams);
-    }
-    onScopeDispose(() => {
-      clientChannel?.removeEventListener("message", onMessage);
-      controller.abort(`Http Abort -> onScopeDispose ${options.url}`);
-      if (serverData.value !== null) {
-        serverData.value = null;
-      }
-    });
-  }
-  return result;
-}
-function applyPayload(payload, result) {
-  if (isHttpErrorPayload(payload)) {
-    result.data = null;
-    result.error = payload;
-    return;
-  }
-  result.data = payload;
-  result.error = null;
-}
-function getChannel() {
-  if (!import.meta.client) {
-    return void 0;
-  }
-  channel ??= new BroadcastChannel(CHANNEL_NAME);
-  return channel;
-}
-function normalizeBroadcastValue(payload) {
-  try {
-    return structuredClone(payload);
-  } catch {
-    return JSON.parse(JSON.stringify(payload));
-  }
-}

package/dist/runtime/http/client.d.ts

@@ -1,3 +0,0 @@
-import { type CreateHttpClientOptions, type HttpClient } from '../utils/shared.js';
-export declare function createHttpClient(options?: CreateHttpClientOptions): HttpClient;
-//# sourceMappingURL=client.d.ts.map

package/dist/runtime/http/client.js

@@ -1,217 +0,0 @@
-import { getRetryDelay, isFormData, sleep } from "../utils/helpers.js";
-import { getHttpRequestMiddlewares, getHttpResponseMiddlewares } from "../utils/middleware.js";
-import {
-  joinUrl
-} from "../utils/shared.js";
-export function createHttpClient(options = {}) {
-  const requestTimeoutMs = options.requestTimeoutMs ?? 8e4;
-  const defaultRetry = {
-    delay: options.retry?.delay ?? 300,
-    retries: options.retry?.retries ?? 3
-  };
-  return {
-    async get(url, config = {}) {
-      const retry = {
-        delay: config.retry?.delay ?? defaultRetry.delay,
-        retries: config.retry?.retries ?? defaultRetry.retries
-      };
-      const attemptRequest = async (attempt) => {
-        const request = await createRequestContext({
-          method: "GET",
-          options,
-          params: config.params,
-          requestTimeoutMs,
-          signal: config.signal,
-          url
-        });
-        try {
-          const result = await fetch(request.url, {
-            credentials: request.credentials,
-            headers: request.headers,
-            method: request.method,
-            signal: request.signal
-          });
-          const response = buildResponse(
-            request.url,
-            await readResponseBody(result),
-            result.status
-          );
-          if (!result.ok && isRetryableStatus(result.status) && attempt < retry.retries) {
-            await sleep(getRetryDelay(attempt, retry.delay));
-            return await attemptRequest(attempt + 1);
-          }
-          await runResponseMiddlewares(response, request, options.responseMiddleware);
-          return response;
-        } catch (error) {
-          if (isAbortError(error) || attempt >= retry.retries) {
-            throw error;
-          }
-          await sleep(getRetryDelay(attempt, retry.delay));
-          return await attemptRequest(attempt + 1);
-        }
-      };
-      return await attemptRequest(0);
-    },
-    async post(url, data, config = {}) {
-      const request = await createRequestContext({
-        body: data,
-        method: "POST",
-        options,
-        params: config.params,
-        requestTimeoutMs,
-        signal: config.signal,
-        url
-      });
-      let requestBody;
-      if (request.body !== void 0) {
-        requestBody = isFormData(request.body) ? request.body : JSON.stringify(request.body);
-      }
-      const result = await fetch(request.url, {
-        body: requestBody,
-        credentials: request.credentials,
-        headers: request.headers,
-        method: request.method,
-        signal: request.signal
-      });
-      const response = buildResponse(
-        request.url,
-        await readResponseBody(result),
-        result.status
-      );
-      await runResponseMiddlewares(response, request, options.responseMiddleware);
-      return response;
-    }
-  };
-}
-function buildRequestUrl(url, params, method) {
-  if (!params || Object.keys(params).length === 0) {
-    return url;
-  }
-  const searchParams = new URLSearchParams();
-  Object.entries(params ?? {}).forEach(([key, value]) => {
-    if (value === void 0 || value === null) {
-      return;
-    }
-    if (Array.isArray(value)) {
-      if (method === "POST") {
-        value.forEach((item) => {
-          searchParams.append(`${key}[]`, String(item));
-        });
-        return;
-      }
-      searchParams.append(key, JSON.stringify(value));
-      return;
-    }
-    searchParams.append(key, String(value));
-  });
-  const query = searchParams.toString();
-  if (!query) {
-    return url;
-  }
-  const separator = url.includes("?") ? "&" : "?";
-  return `${url}${separator}${query}`;
-}
-function buildResponse(url, data, status) {
-  return {
-    config: {
-      url
-    },
-    data,
-    status
-  };
-}
-function createAnySignal(signals) {
-  if (typeof AbortSignal.any === "function") {
-    return AbortSignal.any(signals);
-  }
-  const controller = new AbortController();
-  signals.filter(Boolean).forEach((signal) => {
-    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
-  });
-  return controller.signal;
-}
-async function createRequestContext(input) {
-  const signal = resolveSignal(input.signal, input.requestTimeoutMs);
-  const headers = await createRequestHeaders(
-    input.options.createHeaders,
-    input.method === "POST" && input.body !== void 0 && !isFormData(input.body) ? {
-      "Content-Type": "application/json"
-    } : void 0
-  );
-  const request = {
-    baseURL: await resolveBaseURL(input.options.baseURL),
-    body: input.body,
-    credentials: "include",
-    headers,
-    method: input.method,
-    params: input.params,
-    signal,
-    url: input.url
-  };
-  await runRequestMiddlewares(request, input.options.requestMiddleware);
-  request.url = buildRequestUrl(joinUrl(request.baseURL, request.url), request.params, request.method);
-  return request;
-}
-async function createRequestHeaders(createHeaders, extraHeaders) {
-  const headers = new Headers(createHeaders ? await createHeaders() : void 0);
-  const extra = new Headers(extraHeaders);
-  extra.forEach((value, key) => {
-    headers.set(key, value);
-  });
-  return headers;
-}
-function createTimeoutSignal(ms) {
-  if (typeof AbortSignal.timeout === "function") {
-    return AbortSignal.timeout(ms);
-  }
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(new DOMException("Timed out", "AbortError")), ms);
-  controller.signal.addEventListener("abort", () => clearTimeout(timeoutId), { once: true });
-  return controller.signal;
-}
-function isAbortError(error) {
-  return error instanceof DOMException && error.name === "AbortError";
-}
-function isRetryableStatus(status) {
-  return status >= 500 || status === 429;
-}
-async function readResponseBody(response) {
-  const raw = await response.text();
-  if (!raw) {
-    return null;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return raw;
-  }
-}
-async function resolveBaseURL(baseURL) {
-  if (!baseURL) {
-    return "";
-  }
-  if (typeof baseURL === "function") {
-    return await baseURL() || "";
-  }
-  return baseURL;
-}
-function resolveSignal(signal, requestTimeoutMs) {
-  const timeoutSignal = createTimeoutSignal(requestTimeoutMs);
-  if (Array.isArray(signal)) {
-    return createAnySignal([...signal, timeoutSignal]);
-  }
-  if (signal) {
-    return createAnySignal([signal, timeoutSignal]);
-  }
-  return timeoutSignal;
-}
-async function runRequestMiddlewares(request, middlewares) {
-  for (const middleware of [...getHttpRequestMiddlewares(), ...middlewares ?? []]) {
-    await middleware(request);
-  }
-}
-async function runResponseMiddlewares(response, request, middlewares) {
-  for (const middleware of [...getHttpResponseMiddlewares(), ...middlewares ?? []]) {
-    await middleware(response, request);
-  }
-}

package/dist/runtime/plugin.d.ts

@@ -1,7 +0,0 @@
-declare const _default: import("nuxt/app").Plugin<{
-    http: import("./utils/index.js").HttpClient;
-}> & import("nuxt/app").ObjectPlugin<{
-    http: import("./utils/index.js").HttpClient;
-}>;
-export default _default;
-//# sourceMappingURL=plugin.d.ts.map