@brickflow/http 0.0.14 → 0.0.16

package/dist/runtime/utils/indexeddb.js

@@ -1,222 +0,0 @@
-const dbCache = /* @__PURE__ */ new Map();
-const dbVersions = /* @__PURE__ */ new Map();
-const DB_PREFIX = "smart";
-const allowDb = ["smart-cache-v2"];
-export async function dbDeleteKeysWithPart(part, dbName, storeName) {
-  const db = await openDB(dbName, storeName);
-  const tx = db.transaction(storeName, "readwrite");
-  const store = tx.objectStore(storeName);
-  await new Promise((resolve, reject) => {
-    const req = store.openCursor();
-    req.onerror = () => reject(req.error);
-    req.onsuccess = () => {
-      const cursor = req.result;
-      if (!cursor) {
-        resolve();
-        return;
-      }
-      const key = cursor.key;
-      if (typeof key === "string" && key.startsWith(part) && !key.startsWith(`${part}/`)) {
-        cursor.delete();
-      }
-      cursor.continue();
-    };
-  });
-  await txDone(tx);
-}
-export async function dbGet(key, dbName, storeName) {
-  const db = await openDB(dbName, storeName);
-  const tx = db.transaction(storeName, "readonly");
-  const store = tx.objectStore(storeName);
-  const entry = await requestToPromise(store.get(key));
-  await txDone(tx);
-  if (entry === void 0) {
-    return null;
-  }
-  if (entry.expiresAt === void 0 || Date.now() > entry.expiresAt) {
-    const deleteTx = db.transaction(storeName, "readwrite");
-    deleteTx.objectStore(storeName).delete(key);
-    await txDone(deleteTx);
-    return null;
-  }
-  return entry;
-}
-export async function dbSafeSet(key, value, dbName, storeName, ttl, retries = 1) {
-  if (retries < 0) {
-    throw new Error("IndexedDB quota exceeded permanently");
-  }
-  const db = await openDB(dbName, storeName);
-  const entry = {
-    expiresAt: Date.now() + ttl,
-    hash: await hashData(value),
-    key,
-    value
-  };
-  try {
-    const tx = db.transaction(storeName, "readwrite");
-    const store = tx.objectStore(storeName);
-    if (store.keyPath === null) {
-      store.put(entry, key);
-    } else {
-      store.put(entry);
-    }
-    await txDone(tx);
-  } catch (error) {
-    const domError = error;
-    if (domError?.name === "QuotaExceededError") {
-      await dbEvictOldest(dbName, storeName);
-      await dbSafeSet(key, value, dbName, storeName, ttl, retries - 1);
-      return;
-    }
-    throw domError;
-  }
-}
-export async function hashData(data) {
-  const subtle = globalThis.crypto?.subtle;
-  if (subtle) {
-    const encoded = new TextEncoder().encode(JSON.stringify(data));
-    const buffer = await subtle.digest("SHA-1", encoded);
-    const bytes = Array.from(new Uint8Array(buffer));
-    return bytes.map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  }
-  return fastDevHash(data);
-}
-function attachDbGuards(db) {
-  db.onversionchange = () => {
-    try {
-      db.close();
-    } catch {
-    }
-  };
-}
-async function cleanupOldDatabases() {
-  if (typeof indexedDB.databases !== "function") {
-    return;
-  }
-  let databases;
-  try {
-    databases = await indexedDB.databases();
-  } catch (error) {
-    console.error(error);
-    return;
-  }
-  for (const db of databases) {
-    const name = db.name;
-    if (!name || !name.startsWith(DB_PREFIX) || allowDb.includes(name)) {
-      continue;
-    }
-    try {
-      indexedDB.deleteDatabase(name);
-    } catch {
-    }
-  }
-}
-async function dbEvictOldest(dbName, storeName) {
-  const db = await openDB(dbName, storeName);
-  const tx = db.transaction(storeName, "readwrite");
-  const store = tx.objectStore(storeName);
-  const total = await requestToPromise(store.count());
-  if (total === 0) {
-    await txDone(tx);
-    return;
-  }
-  const limit = Math.floor(total / 2);
-  if (limit === 0 || !store.indexNames.contains("expiresAt")) {
-    await txDone(tx);
-    return;
-  }
-  const index = store.index("expiresAt");
-  let removed = 0;
-  await new Promise((resolve, reject) => {
-    const req = index.openCursor();
-    req.onerror = () => reject(req.error);
-    req.onsuccess = () => {
-      const cursor = req.result;
-      if (cursor === null || removed >= limit) {
-        resolve();
-        return;
-      }
-      cursor.delete();
-      removed += 1;
-      cursor.continue();
-    };
-  });
-  await txDone(tx);
-  if (removed === 0 && total > 0) {
-    throw new Error("IndexedDB eviction removed 0 items");
-  }
-}
-function fastDevHash(data) {
-  const text = JSON.stringify(data);
-  let hash = 0;
-  for (let index = 0; index < text.length; index += 1) {
-    const code = text.charCodeAt(index);
-    hash = (hash << 5) - hash + code;
-    hash |= 0;
-  }
-  return Math.abs(hash).toString(16);
-}
-async function openDB(dbName, storeName) {
-  const currentVersion = dbVersions.get(dbName) ?? 1;
-  const cacheKey = `${dbName}@v${currentVersion}`;
-  const cached = dbCache.get(cacheKey);
-  if (cached !== void 0) {
-    return cached;
-  }
-  await cleanupOldDatabases();
-  const openAtVersion = (version) => new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName, version);
-    req.onupgradeneeded = () => {
-      const db2 = req.result;
-      let store;
-      if (db2.objectStoreNames.contains(storeName)) {
-        const tx = req.transaction;
-        if (tx === null) {
-          throw new Error("[openDB] Missing transaction during upgrade");
-        }
-        store = tx.objectStore(storeName);
-      } else {
-        store = db2.createObjectStore(storeName, { keyPath: "key" });
-      }
-      if (!store.indexNames.contains("expiresAt")) {
-        store.createIndex("expiresAt", "expiresAt");
-      }
-    };
-    req.onblocked = () => reject(new Error(`[openDB] Upgrade blocked for "${dbName}"`));
-    req.onsuccess = () => {
-      const db2 = req.result;
-      attachDbGuards(db2);
-      resolve(db2);
-    };
-    req.onerror = () => reject(req.error);
-  });
-  const promise = openAtVersion(currentVersion);
-  dbCache.set(cacheKey, promise);
-  const db = await promise;
-  if (db.objectStoreNames.contains(storeName)) {
-    dbVersions.set(dbName, currentVersion);
-    return db;
-  }
-  try {
-    db.close();
-  } catch {
-  }
-  const nextVersion = currentVersion + 1;
-  dbVersions.set(dbName, nextVersion);
-  const upgraded = await openAtVersion(nextVersion);
-  dbCache.set(`${dbName}@v${nextVersion}`, Promise.resolve(upgraded));
-  return upgraded;
-}
-function requestToPromise(req) {
-  return new Promise((resolve, reject) => {
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-function txDone(tx) {
-  return new Promise((resolve, reject) => {
-    tx.oncomplete = () => resolve();
-    tx.onerror = () => reject(tx.error ?? new Error("Transaction error"));
-    tx.onabort = () => reject(tx.error ?? new Error("Transaction aborted"));
-  });
-}

package/dist/runtime/utils/middleware.d.ts

@@ -1,8 +0,0 @@
-import type { HttpRequestMiddleware, HttpResponseMiddleware } from './shared.js';
-export declare function addHttpRequestMiddleware(middleware: HttpRequestMiddleware): void;
-export declare function addHttpResponseMiddleware(middleware: HttpResponseMiddleware): void;
-export declare function getHttpRequestMiddlewares(): HttpRequestMiddleware[];
-export declare function getHttpResponseMiddlewares(): HttpResponseMiddleware[];
-export declare function removeHttpRequestMiddleware(middleware: HttpRequestMiddleware): void;
-export declare function removeHttpResponseMiddleware(middleware: HttpResponseMiddleware): void;
-//# sourceMappingURL=middleware.d.ts.map

package/dist/runtime/utils/middleware.js

@@ -1,20 +0,0 @@
-const requestMiddlewares = /* @__PURE__ */ new Set();
-const responseMiddlewares = /* @__PURE__ */ new Set();
-export function addHttpRequestMiddleware(middleware) {
-  requestMiddlewares.add(middleware);
-}
-export function addHttpResponseMiddleware(middleware) {
-  responseMiddlewares.add(middleware);
-}
-export function getHttpRequestMiddlewares() {
-  return [...requestMiddlewares];
-}
-export function getHttpResponseMiddlewares() {
-  return [...responseMiddlewares];
-}
-export function removeHttpRequestMiddleware(middleware) {
-  requestMiddlewares.delete(middleware);
-}
-export function removeHttpResponseMiddleware(middleware) {
-  responseMiddlewares.delete(middleware);
-}

package/dist/runtime/utils/shared.d.ts

@@ -1,83 +0,0 @@
-export interface CreateHttpClientOptions {
-    baseURL?: HttpBaseURL;
-    createHeaders?: () => HeadersInit | Promise<HeadersInit>;
-    requestMiddleware?: HttpRequestMiddleware[];
-    requestTimeoutMs?: number;
-    responseMiddleware?: HttpResponseMiddleware[];
-    retry?: HttpRetryConfig;
-}
-export interface GetConfig<TParams extends HttpParam = HttpParam, _TError extends HttpErrorPayload = HttpErrorPayload> extends HttpConfig<TParams> {
-    retry?: HttpRetryConfig;
-}
-export type HttpBaseURL = HttpBaseURLResolver | string;
-export type HttpBaseURLResolver = () => Promise<string> | string;
-export interface HttpClient {
-    get: <TData = unknown, TParams extends HttpParam = HttpParam, TError extends HttpErrorPayload = HttpErrorPayload>(url: string, config?: GetConfig<TParams, TError>) => Promise<HttpResponse<HttpPayload<TData, TError>>>;
-    post: <TData = unknown, TParams extends HttpParam = HttpParam, TError extends HttpErrorPayload = HttpErrorPayload>(url: string, data?: FormData | Record<string, unknown>, config?: PostConfig<TParams, TError>) => Promise<HttpResponse<HttpPayload<TData, TError>>>;
-}
-export interface HttpConfig<TParams extends HttpParam = HttpParam> {
-    params?: TParams;
-    signal?: AbortSignal | AbortSignal[];
-}
-export interface HttpErrorPayload {
-    [key: string]: unknown;
-    kind?: string;
-    message?: string;
-    status: 'error';
-}
-export type HttpParam = Record<string, HttpParamValue>;
-export type HttpParamValue = HttpPrimitive | null | ReadonlyArray<HttpPrimitive> | undefined;
-export type HttpPayload<TData, TError extends HttpErrorPayload = HttpErrorPayload> = TData | TError;
-export type HttpPrimitive = boolean | number | string;
-export interface HttpRequestContext<TParams extends HttpParam = HttpParam, TBody = FormData | Record<string, unknown> | undefined> {
-    baseURL: string;
-    body?: TBody;
-    credentials: RequestCredentials;
-    headers: Headers;
-    method: 'GET' | 'POST';
-    params?: TParams;
-    signal: AbortSignal;
-    url: string;
-}
-export type HttpRequestMiddleware = (request: HttpRequestContext) => Promise<void> | void;
-export interface HttpResponse<TData = unknown> {
-    config: {
-        url: string;
-    };
-    data: TData;
-    status: number;
-}
-export type HttpResponseMiddleware = (response: HttpResponse, request: HttpRequestContext) => Promise<void> | void;
-export interface HttpRetryConfig {
-    /**
-     * Delay between retry attempts in milliseconds.
-     *
-     * @default 300
-     */
-    delay?: number;
-    /**
-     * Number of retry attempts for GET requests.
-     *
-     * @default 3
-     */
-    retries?: number;
-}
-export interface HttpRuntimeConfig {
-    baseURL: string;
-    cache: boolean;
-    cacheDbName: 'smart-cache-v2';
-    cacheStoreName: string;
-    cacheTtlMs: number;
-    clientEnvHeader: boolean;
-    defaultHeaders: Record<string, string>;
-    disableCacheInDev: boolean;
-    requestTimeoutMs: number;
-    retry: Required<HttpRetryConfig>;
-}
-export interface PostConfig<TParams extends HttpParam = HttpParam, _TError extends HttpErrorPayload = HttpErrorPayload> extends HttpConfig<TParams> {
-}
-export declare function createHttpUrl(url: string, params?: HttpParam): string;
-export declare function createNetworkError(error: unknown): HttpErrorPayload;
-export declare function isHttpErrorPayload(value: unknown): value is HttpErrorPayload;
-export declare function joinUrl(baseURL: string, url: string): string;
-//# sourceMappingURL=shared.d.ts.map

package/dist/runtime/utils/shared.js

@@ -1,50 +0,0 @@
-export function createHttpUrl(url, params = {}) {
-  const query = serializeParams(params);
-  if (!query) {
-    return url;
-  }
-  return `${url}?${query}`;
-}
-export function createNetworkError(error) {
-  return {
-    kind: "network_error",
-    message: error instanceof Error ? error.message : "Network request failed",
-    status: "error"
-  };
-}
-export function isHttpErrorPayload(value) {
-  return Boolean(value && typeof value === "object" && "status" in value && value.status === "error");
-}
-export function joinUrl(baseURL, url) {
-  if (isAbsoluteUrl(url)) {
-    return url;
-  }
-  if (!baseURL) {
-    return url;
-  }
-  const left = baseURL.endsWith("/") ? baseURL.slice(0, -1) : baseURL;
-  const right = url.startsWith("/") ? url.slice(1) : url;
-  return `${left}/${right}`;
-}
-function isAbsoluteUrl(url) {
-  return /^https?:\/\//.test(url) || url.startsWith("//");
-}
-function serializeParams(params = {}) {
-  const query = new URLSearchParams();
-  Object.entries(params).forEach(([key, value]) => {
-    const serializedValue = serializeParamValue(value);
-    if (serializedValue !== null) {
-      query.append(key, serializedValue);
-    }
-  });
-  return query.toString();
-}
-function serializeParamValue(value) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (Array.isArray(value)) {
-    return JSON.stringify(value);
-  }
-  return String(value);
-}

package/dist/runtime/utils/typed.d.ts

@@ -1,46 +0,0 @@
-import type { GetConfig, HttpClient, HttpErrorPayload, HttpParam, HttpPayload, HttpResponse, PostConfig } from './shared.js';
-declare global {
-    interface BrickflowHttpRouteMap {
-    }
-}
-export type HttpRouteBody<TRoute extends HttpRouteDefinition> = TRoute extends {
-    body: infer TBody;
-} ? TBody extends FormData | Record<string, unknown> ? TBody : FormData | Record<string, unknown> : FormData | Record<string, unknown>;
-export type HttpRouteData<TRoute extends HttpRouteDefinition> = TRoute extends {
-    data: infer TData;
-} ? TData : unknown;
-export interface HttpRouteDefinition {
-    body?: FormData | Record<string, unknown>;
-    data?: unknown;
-    error?: HttpErrorPayload;
-    params?: HttpParam;
-}
-export type HttpRouteError<TRoute extends HttpRouteDefinition> = TRoute extends {
-    error: infer TError;
-} ? TError extends HttpErrorPayload ? TError : HttpErrorPayload : HttpErrorPayload;
-export interface HttpRouteMap extends BrickflowHttpRouteMap {
-}
-export type HttpRouteParams<TRoute extends HttpRouteDefinition> = TRoute extends {
-    params: infer TParams;
-} ? TParams extends HttpParam ? TParams : HttpParam : HttpParam;
-export type ResolveHttpRoute<TRoutes, TUrl extends string> = TUrl extends KnownHttpRoute<TRoutes> ? HttpRouteLike<TRoutes[TUrl]> : HttpRouteDefinition;
-export interface StrictTypedHttpClient<TRoutes = HttpRouteMap> {
-    get<TUrl extends KnownHttpRoute<TRoutes>>(url: TUrl, config?: TypedGetConfig<TRoutes, TUrl>): Promise<TypedHttpResponse<TRoutes, TUrl>>;
-    post<TUrl extends KnownHttpRoute<TRoutes>>(url: TUrl, data?: HttpRouteBody<ResolveHttpRoute<TRoutes, TUrl>>, config?: TypedPostConfig<TRoutes, TUrl>): Promise<TypedHttpResponse<TRoutes, TUrl>>;
-}
-export type TypedGetConfig<TRoutes, TUrl extends string> = GetConfig<HttpRouteParams<ResolveHttpRoute<TRoutes, TUrl>>, HttpRouteError<ResolveHttpRoute<TRoutes, TUrl>>>;
-export interface TypedHttpClient<TRoutes = HttpRouteMap> extends Omit<HttpClient, 'get' | 'post'> {
-    get<TUrl extends KnownHttpRoute<TRoutes>>(url: TUrl, config?: TypedGetConfig<TRoutes, TUrl>): Promise<TypedHttpResponse<TRoutes, TUrl>>;
-    get<TData = unknown, TParams extends HttpParam = HttpParam, TError extends HttpErrorPayload = HttpErrorPayload>(url: string, config?: GetConfig<TParams, TError>): Promise<HttpResponse<HttpPayload<TData, TError>>>;
-    post<TUrl extends KnownHttpRoute<TRoutes>>(url: TUrl, data?: HttpRouteBody<ResolveHttpRoute<TRoutes, TUrl>>, config?: TypedPostConfig<TRoutes, TUrl>): Promise<TypedHttpResponse<TRoutes, TUrl>>;
-    post<TData = unknown, TParams extends HttpParam = HttpParam, TError extends HttpErrorPayload = HttpErrorPayload>(url: string, data?: FormData | Record<string, unknown>, config?: PostConfig<TParams, TError>): Promise<HttpResponse<HttpPayload<TData, TError>>>;
-}
-export type TypedHttpResponse<TRoutes, TUrl extends string> = HttpResponse<HttpPayload<HttpRouteData<ResolveHttpRoute<TRoutes, TUrl>>, HttpRouteError<ResolveHttpRoute<TRoutes, TUrl>>>>;
-export type TypedPostConfig<TRoutes, TUrl extends string> = PostConfig<HttpRouteParams<ResolveHttpRoute<TRoutes, TUrl>>, HttpRouteError<ResolveHttpRoute<TRoutes, TUrl>>>;
-type HttpRouteLike<TValue> = TValue extends HttpRouteDefinition ? TValue : HttpRouteDefinition;
-type KnownHttpRoute<TRoutes> = Extract<keyof TRoutes, string>;
-export declare function createStrictHttpClient<TRoutes = HttpRouteMap>(client: HttpClient): StrictTypedHttpClient<TRoutes>;
-export declare function createTypedHttpClient<TRoutes = HttpRouteMap>(client: HttpClient): TypedHttpClient<TRoutes>;
-export declare function defineHttpRoutes<const TRoutes extends Record<string, HttpRouteDefinition>>(routes: TRoutes): TRoutes;
-export {};
-//# sourceMappingURL=typed.d.ts.map

package/dist/runtime/utils/typed.js

@@ -1,9 +0,0 @@
-export function createStrictHttpClient(client) {
-  return client;
-}
-export function createTypedHttpClient(client) {
-  return client;
-}
-export function defineHttpRoutes(routes) {
-  return routes;
-}

package/dist/types.d.mts

@@ -1,11 +0,0 @@
-export { type CreateHttpClientOptions, type GetConfig, type HttpBaseURL, type HttpBaseURLResolver, type HttpClient, type HttpConfig, type HttpErrorPayload, type HttpParam, type HttpPayload, type HttpRequestContext, type HttpRequestMiddleware, type HttpResponse, type HttpResponseMiddleware, type HttpRetryConfig, type HttpRuntimeConfig, type PostConfig } from '../dist/runtime/utils/shared.js'
-
-export { type createHttpClient } from '../dist/runtime/http/client.js'
-
-export { type addHttpRequestMiddleware, type addHttpResponseMiddleware, type removeHttpRequestMiddleware, type removeHttpResponseMiddleware } from '../dist/runtime/utils/middleware.js'
-
-export { type HttpRouteBody, type HttpRouteData, type HttpRouteDefinition, type HttpRouteError, type HttpRouteMap, type HttpRouteParams, type ResolveHttpRoute, type StrictTypedHttpClient, type TypedGetConfig, type TypedHttpClient, type TypedHttpResponse, type TypedPostConfig, type createStrictHttpClient, type createTypedHttpClient, type defineHttpRoutes } from '../dist/runtime/utils/typed.js'
-
-export { default } from './module.mjs'
-
-export { type ModuleOptions } from './module.mjs'