@storyblok/management-api-client 0.1.0 → 0.1.1

package/src/client/client.ts

@@ -1,246 +0,0 @@
-import { getManagementBaseUrl, getRegion } from '@storyblok/region-helper';
-import type { Client, Config, RequestOptions } from './types';
-import {
-  buildUrl,
-  createConfig,
-  createInterceptors,
-  getParseAs,
-  mergeConfigs,
-  mergeHeaders,
-  setAuthParams,
-} from './utils';
-
-type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
-  body?: any;
-  headers: ReturnType<typeof mergeHeaders>;
-};
-
-export const createClient = (config: Config = {}): Client => {
-  let _config = mergeConfigs(createConfig(), config);
-
-  const getConfig = (): Config => ({ ..._config });
-
-  const setConfig = (config: Config): Config => {
-    _config = mergeConfigs(_config, config);
-    return getConfig();
-  };
-
-  const interceptors = createInterceptors<
-    Request,
-    Response,
-    unknown,
-    RequestOptions
-  >();
-
-  const request: Client['request'] = async (options) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-    };
-
-    // If the baseUrl is not set and we have a space_id, we can attempt toinfer the region
-    if (!_config.baseUrl && options.path?.space_id) {
-      const region = getRegion(options.path.space_id as number);
-      if (region) {
-        opts.baseUrl = getManagementBaseUrl(region, 'https');
-      }
-    }
-
-    if (opts.security) {
-      await setAuthParams({
-        ...opts,
-        security: opts.security,
-      });
-    }
-
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-
-    if (opts.body && opts.bodySerializer) {
-      opts.body = opts.bodySerializer(opts.body);
-    }
-
-    // remove Content-Type header if body is empty to avoid sending invalid requests
-    if (opts.body === undefined || opts.body === '') {
-      opts.headers.delete('Content-Type');
-    }
-
-    const url = buildUrl(opts);
-    const requestInit: ReqInit = {
-      redirect: 'follow',
-      ...opts,
-    };
-
-    let request = new Request(url, requestInit);
-
-    for (const fn of interceptors.request._fns) {
-      if (fn) {
-        request = await fn(request, opts);
-      }
-    }
-
-    // fetch must be assigned here, otherwise it would throw the error:
-    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-    const _fetch = opts.fetch!;
-    
-    // Execute with retry logic by recreating the request for each attempt
-    let response = await executeWithRetry(_fetch, url, requestInit, {
-      maxRetries: 3,
-      retryDelay: 1000
-    });
-
-    for (const fn of interceptors.response._fns) {
-      if (fn) {
-        response = await fn(response, request, opts);
-      }
-    }
-
-    const result = {
-      request,
-      response,
-    };
-
-    if (response.ok) {
-      if (
-        response.status === 204 ||
-        response.headers.get('Content-Length') === '0'
-      ) {
-        return opts.responseStyle === 'data'
-          ? {}
-          : {
-              data: {},
-              ...result,
-            };
-      }
-
-      const parseAs =
-        (opts.parseAs === 'auto'
-          ? getParseAs(response.headers.get('Content-Type'))
-          : opts.parseAs) ?? 'json';
-
-      let data: any;
-      switch (parseAs) {
-        case 'arrayBuffer':
-        case 'blob':
-        case 'formData':
-        case 'json':
-        case 'text':
-          data = await response[parseAs]();
-          break;
-        case 'stream':
-          return opts.responseStyle === 'data'
-            ? response.body
-            : {
-                data: response.body,
-                ...result,
-              };
-      }
-
-      if (parseAs === 'json') {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
-
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
-      }
-
-      return opts.responseStyle === 'data'
-        ? data
-        : {
-            data,
-            ...result,
-          };
-    }
-
-    const textError = await response.text();
-    let jsonError: unknown;
-
-    try {
-      jsonError = JSON.parse(textError);
-    } catch {
-      // noop
-    }
-
-    const error = jsonError ?? textError;
-    let finalError = error;
-
-    for (const fn of interceptors.error._fns) {
-      if (fn) {
-        finalError = (await fn(error, response, request, opts)) as string;
-      }
-    }
-
-    finalError = finalError || ({} as string);
-
-    if (opts.throwOnError) {
-      throw finalError;
-    }
-
-    // TODO: we probably want to return error and improve types
-    return opts.responseStyle === 'data'
-      ? undefined
-      : {
-          error: finalError,
-          ...result,
-        };
-  };
-
-  // Helper function to execute fetch with retry logic
-  async function executeWithRetry(
-    fetchFn: any,
-    url: string,
-    requestInit: ReqInit,
-    retryConfig: { maxRetries: number; retryDelay: number },
-    attempt: number = 0
-  ): Promise<Response> {
-    try {
-      const request = new Request(url, requestInit);
-      const response = await fetchFn(request);
-      
-      if (response.status === 429 && attempt < retryConfig.maxRetries) {
-        const retryAfter = response.headers.get('retry-after');
-        const delay = retryAfter ? parseInt(retryAfter) * 1000 : retryConfig.retryDelay;
-        
-        await new Promise(resolve => setTimeout(resolve, delay));
-        
-        // Use the original unconsumed request for retry
-        return executeWithRetry(fetchFn, url, requestInit, retryConfig, attempt + 1);
-      }
-      
-      return response;
-    } catch (error) {
-      // If it's a network error and we haven't exceeded retries, try again
-      if (attempt < retryConfig.maxRetries) {
-        const delay = retryConfig.retryDelay;
-        await new Promise(resolve => setTimeout(resolve, delay));
-        
-        // Use the original unconsumed request for retry
-        return executeWithRetry(fetchFn, url, requestInit, retryConfig, attempt + 1);
-      }
-      
-      throw error;
-    }
-  }
-
-  return {
-    buildUrl,
-    connect: (options) => request({ ...options, method: 'CONNECT' }),
-    delete: (options) => request({ ...options, method: 'DELETE' }),
-    get: (options) => request({ ...options, method: 'GET' }),
-    getConfig,
-    head: (options) => request({ ...options, method: 'HEAD' }),
-    interceptors,
-    options: (options) => request({ ...options, method: 'OPTIONS' }),
-    patch: (options) => request({ ...options, method: 'PATCH' }),
-    post: (options) => request({ ...options, method: 'POST' }),
-    put: (options) => request({ ...options, method: 'PUT' }),
-    request,
-    setConfig,
-    trace: (options) => request({ ...options, method: 'TRACE' }),
-  };
-};

package/src/client/index.ts

@@ -1,22 +0,0 @@
-export type { Auth } from '../core/auth';
-export type { QuerySerializerOptions } from '../core/bodySerializer';
-export {
-  formDataBodySerializer,
-  jsonBodySerializer,
-  urlSearchParamsBodySerializer,
-} from '../core/bodySerializer';
-export { buildClientParams } from '../core/params';
-export { createClient } from './client';
-export type {
-  Client,
-  ClientOptions,
-  Config,
-  CreateClientConfig,
-  Options,
-  OptionsLegacyParser,
-  RequestOptions,
-  RequestResult,
-  ResponseStyle,
-  TDataShape,
-} from './types';
-export { createConfig, mergeHeaders } from './utils';

package/src/client/types.ts

@@ -1,222 +0,0 @@
-import type { Auth } from '../core/auth';
-import type {
-  Client as CoreClient,
-  Config as CoreConfig,
-} from '../core/types';
-import type { Middleware } from './utils';
-
-export type ResponseStyle = 'data' | 'fields';
-
-export interface Config<T extends ClientOptions = ClientOptions>
-  extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
-    CoreConfig {
-  /**
-   * Base URL for all requests made by this client.
-   */
-  baseUrl?: T['baseUrl'];
-  /**
-   * Fetch API implementation. You can use this option to provide a custom
-   * fetch instance.
-   *
-   * @default globalThis.fetch
-   */
-  fetch?: (request: Request) => ReturnType<typeof fetch>;
-  /**
-   * Please don't use the Fetch client for Next.js applications. The `next`
-   * options won't have any effect.
-   *
-   * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
-   */
-  next?: never;
-  /**
-   * Return the response data parsed in a specified format. By default, `auto`
-   * will infer the appropriate method from the `Content-Type` response header.
-   * You can override this behavior with any of the {@link Body} methods.
-   * Select `stream` if you don't want to parse response data at all.
-   *
-   * @default 'auto'
-   */
-  parseAs?:
-    | 'arrayBuffer'
-    | 'auto'
-    | 'blob'
-    | 'formData'
-    | 'json'
-    | 'stream'
-    | 'text';
-  /**
-   * Should we return only data or multiple fields (data, error, response, etc.)?
-   *
-   * @default 'fields'
-   */
-  responseStyle?: ResponseStyle;
-  /**
-   * Throw an error instead of returning it in the response?
-   *
-   * @default false
-   */
-  throwOnError?: T['throwOnError'];
-}
-
-export interface RequestOptions<
-  TResponseStyle extends ResponseStyle = 'fields',
-  ThrowOnError extends boolean = boolean,
-  Url extends string = string,
-> extends Config<{
-    responseStyle: TResponseStyle;
-    throwOnError: ThrowOnError;
-  }> {
-  /**
-   * Any body that you want to add to your request.
-   *
-   * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
-   */
-  body?: unknown;
-  path?: Record<string, unknown>;
-  query?: Record<string, unknown>;
-  /**
-   * Security mechanism(s) to use for the request.
-   */
-  security?: ReadonlyArray<Auth>;
-  url: Url;
-}
-
-export type RequestResult<
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = boolean,
-  TResponseStyle extends ResponseStyle = 'fields',
-> = ThrowOnError extends true
-  ? Promise<
-      TResponseStyle extends 'data'
-        ? TData extends Record<string, unknown>
-          ? TData[keyof TData]
-          : TData
-        : {
-            data: TData extends Record<string, unknown>
-              ? TData[keyof TData]
-              : TData;
-            request: Request;
-            response: Response;
-          }
-    >
-  : Promise<
-      TResponseStyle extends 'data'
-        ?
-            | (TData extends Record<string, unknown>
-                ? TData[keyof TData]
-                : TData)
-            | undefined
-        : (
-            | {
-                data: TData extends Record<string, unknown>
-                  ? TData[keyof TData]
-                  : TData;
-                error: undefined;
-              }
-            | {
-                data: undefined;
-                error: TError extends Record<string, unknown>
-                  ? TError[keyof TError]
-                  : TError;
-              }
-          ) & {
-            request: Request;
-            response: Response;
-          }
-    >;
-
-export interface ClientOptions {
-  baseUrl?: string;
-  responseStyle?: ResponseStyle;
-  throwOnError?: boolean;
-}
-
-type MethodFn = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
-  TResponseStyle extends ResponseStyle = 'fields',
->(
-  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'>,
-) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-
-type RequestFn = <
-  TData = unknown,
-  TError = unknown,
-  ThrowOnError extends boolean = false,
-  TResponseStyle extends ResponseStyle = 'fields',
->(
-  options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, 'method'> &
-    Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, 'method'>,
-) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-
-type BuildUrlFn = <
-  TData extends {
-    body?: unknown;
-    path?: Record<string, unknown>;
-    query?: Record<string, unknown>;
-    url: string;
-  },
->(
-  options: Pick<TData, 'url'> & Options<TData>,
-) => string;
-
-export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
-  interceptors: Middleware<Request, Response, unknown, RequestOptions>;
-};
-
-/**
- * The `createClientConfig()` function will be called on client initialization
- * and the returned object will become the client's initial configuration.
- *
- * You may want to initialize your client this way instead of calling
- * `setConfig()`. This is useful for example if you're using Next.js
- * to ensure your client always has the correct values.
- */
-export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
-  override?: Config<ClientOptions & T>,
-) => Config<Required<ClientOptions> & T>;
-
-export interface TDataShape {
-  body?: unknown;
-  headers?: unknown;
-  path?: unknown;
-  query?: unknown;
-  url: string;
-}
-
-type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
-
-export type Options<
-  TData extends TDataShape = TDataShape,
-  ThrowOnError extends boolean = boolean,
-  TResponseStyle extends ResponseStyle = 'fields',
-> = OmitKeys<
-  RequestOptions<TResponseStyle, ThrowOnError>,
-  'body' | 'path' | 'query' | 'url'
-> &
-  Omit<TData, 'url'>;
-
-export type OptionsLegacyParser<
-  TData = unknown,
-  ThrowOnError extends boolean = boolean,
-  TResponseStyle extends ResponseStyle = 'fields',
-> = TData extends { body?: any }
-  ? TData extends { headers?: any }
-    ? OmitKeys<
-        RequestOptions<TResponseStyle, ThrowOnError>,
-        'body' | 'headers' | 'url'
-      > &
-        TData
-    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'body' | 'url'> &
-        TData &
-        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'headers'>
-  : TData extends { headers?: any }
-    ? OmitKeys<
-        RequestOptions<TResponseStyle, ThrowOnError>,
-        'headers' | 'url'
-      > &
-        TData &
-        Pick<RequestOptions<TResponseStyle, ThrowOnError>, 'body'>
-    : OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, 'url'> & TData;