@troveng/swagger-gen-js/utility/index.js

// @flow
// API - UTILITIES
// =============================================================================
// General purpose utilities required by the generated output files.

// FLUX STANDARD ACTIONS
// These may be brought in by something like flow-typed in the future. For the
// time being, this is a relatively faithful conversion of the TypeScript
// equivalents defined in https://github.com/redux-utilities/flux-standard-action/blob/master/src/index.d.ts

/* eslint-disable no-use-before-define */
export type ActionType = string;
export type NormalFSA<Payload: mixed | Error = typeof undefined, Meta: mixed = typeof undefined> = {|
  type: ActionType,
  payload: Payload,
  error: boolean,
  meta: Meta
|};
export type FluxStandardAction<Payload, Meta> = NormalFSA<Payload, Meta>;
export type FSA<Payload, Meta> = NormalFSA<Payload, Meta>;

// JSON TYPES
export type PrimitiveType = null | string | boolean | number;
export type JSONObject = ({ [key: string]: PrimitiveType | JSONObject | JSONArray | void });
export type JSONArray = Array<PrimitiveType> | Array<JSONObject> | Array<JSONArray>;
export type JSONType = JSONObject | JSONArray | PrimitiveType;

// SWAGGER GEN JS UTILITY TYPES
export type ApiEndpointState = {
  +success: JSONType | null,
  +failure: JSONType | null,
  +timeout: JSONType | null,
  +mistake: JSONType | null,
  +isFetching: boolean,
  +lastUpdate: number | null,
  +lastResult: 'success' | 'failure' | 'timeout' | 'mistake' | null,
};
export type KeyedCollectionState =
  & ApiEndpointState
  & { +collection: { [string]: JSONObject } };

export type ReducerState<Name: string> =
  & { +[string]: ApiEndpointState }
  & { +[Name]: ApiEndpointState };
export type KeyedReducerState<Name: string> =
  & { +[string]: KeyedCollectionState }
  & { +[Name]: KeyedCollectionState };

export type ParamKey = number | string;
export type ParamValue = number | string | boolean;
export type ParamsPair = [ParamKey, ParamValue];
export type ParamsArray = Array<ParamsPair>;
export type ParamsObject = { [ParamKey]: * };
/* eslint-enable no-use-before-define */


const queryPrefixRegexp = new RegExp(/^\?=/);

const validateParamsPair = ([key, value]) => {
  if (typeof key !== 'string') {
    throw new Error(`Expected ParamsObject to have string keys, not "${typeof key}""`);
  }
  if (typeof value !== 'string' && typeof value !== 'number' && typeof value !== 'boolean') {
    throw new Error(`Expected ParamsObject values to be strings, numbers, or booleans, not "${typeof value}"`);
  }
};

export const validateParamsObject = (params: ParamsObject) => {
  if (params && typeof params === 'object') {
    Object.entries(params).forEach(validateParamsPair);
  } else {
    throw new Error('Could not validate ParamsObject: Not an object');
  }
};

export const validateParamsArray = (params: ParamsArray) => {
  if (params && Array.isArray(params)) {
    params.forEach(validateParamsPair);
  } else {
    throw new Error('Could not validate ParamsArray: Not an array');
  }
};

// Outputs param string pairs in the format 'foo=bar'
const createParamsPairString = (paramsPair: ParamsPair): string => {
  if (Array.isArray(paramsPair) && paramsPair.length === 2) {
    if (typeof paramsPair[0] !== 'string') {
      throw new TypeError('paramsPair[0] must be a string');
    }

    if (!['number', 'string', 'boolean'].includes(typeof paramsPair[1])) {
      throw new TypeError('paramsPair[1] must be a number, string, or boolean');
    }

    return `${encodeURIComponent(String(paramsPair[0]))}=${encodeURIComponent(String(paramsPair[1]))}`;
  }

  throw new TypeError('paramsPair must be an array with two entries');
};

// Converts a URI string back into its original type. Deliberately very narrow
// in scope. Certainly doesn't cover all possible abuses of URI strings.
const restoreOriginalType = (text: string): * => {
  if (typeof text === 'string') {
    const decodedText = decodeURIComponent(text);

    if (!isNaN(decodedText)) {
      // Text is a valid number
      // NOTE: This absolutely does not handle hex or octal. Until someone needs
      // it to do more, we'll continue to naively use parseFloat.
      return parseFloat(decodedText);
    }

    if (decodedText === 'true' || decodedText === 'false') {
      // Text is a valid boolean
      return decodedText === 'true';
    }

    // Text is a valid string, and was not a number or boolean
    return decodedText;
  }

  throw new Error('Could not restore type: not a number, string, or boolean');
};

// Convert a 2D array into a query parameter string
export const arrayToParamString = (paramsArray: ParamsArray = []): string => {
  if (Array.isArray(paramsArray)) {
    return paramsArray.map(createParamsPairString).join('&');
  }

  throw new TypeError('paramsArray must be an Array');
};

// Convert a query parameter string into a 2D array
export const paramStringToArray = (paramsString: string = ''): ParamsArray => {
  if (typeof paramsString === 'string') {
    const cleanedPairs: Array<string> = paramsString.replace(queryPrefixRegexp, '').split('&');

    return cleanedPairs.map((param: string) => {
      const [key, value] = param.split('=');

      return [decodeURIComponent(key), restoreOriginalType(value)];
    });
  }

  throw new TypeError('paramsString must be a string');
};

// Convert an object into a query parameter string
export const objectToParamString = (paramsObject: ParamsObject = {}): string => {
  if (paramsObject && typeof paramsObject === 'object') {
    const entries = Object.keys(paramsObject)
      .map(key => [key, paramsObject[key]]);

    return arrayToParamString(entries);
  }

  throw new TypeError('paramsObject must be an Object');
};

// Convert a query parameter string into an object
export const paramStringToObject = (paramsString: string = '') => {
  const paramsArray: ParamsArray = paramStringToArray(paramsString);

  if (Array.isArray(paramsArray)) {
    const data = {};

    paramsArray.forEach(([key, value]: ParamsPair) => {
      data[key] = value;
    });

    return data;
  }

  throw new Error('Could not convert param string to object beacuse the intermediate Array was not created');
};

export const convertToParamString = (content: ParamsArray | ParamsObject = {}): string => {
  if (Array.isArray(content)) {
    return arrayToParamString(content);
  } else if (content !== null && typeof content === 'object') {
    return objectToParamString(content);
  }

  throw new Error('convertToParamString requires an array or an object as its first parameter');
};

export const convertQueryToString = (content: ParamsArray | ParamsObject = {}): string => {
  const convertedString = convertToParamString(content);

  if (typeof convertedString === 'string') {
    if (convertedString.length) {
      return `?${convertedString}`;
    }

    // In the event that we successfully 'converted' an empty object or array -
    // which is completely legal - we should return an empty string.
    return '';
  }

  throw new Error('Query conversion failed');
};

// SAGA HELPERS
export const getInit = () => {};
export const getApiPath = () => '';

// REDUCER HELPERS
export const initialEndpointState: ApiEndpointState = {
  success: null,
  failure: null,
  timeout: null,
  mistake: null,
  isFetching: false,
  lastUpdate: null,
  lastResult: null,
};
export const initialKeyedCollectionState: ApiEndpointState & KeyedCollectionState = {
  ...initialEndpointState,
  collection: {},
};

const rekeyObject = (key: string, obj: JSONObject) => {
  if (obj && typeof obj[key] === 'string') {
    return { [obj[key]]: obj };
  }

  console.trace(`Could not key response obect by key '${key}'`);
  console.error(JSON.stringify(obj, null, 2));

  return {};
};

export const handleKeyedCollection = (key: string, collection: { [string]: JSONObject } = {}, response: JSONObject | Array<JSONObject>) => {
  if (Array.isArray(response)) {
    return response.map(obj => rekeyObject(key, obj)).reduce((prev, next) => ({ ...prev, ...next }), collection);
  }

  return { ...collection, ...rekeyObject(key, response) };
};

export const handleRequest = <Name: string, State: ReducerState<Name>>(
  name: Name,
  state: State,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialEndpointState,
      ...state[name],
      isFetching: true,
    },
  }
);

export const handleSuccess = <Name: string, State: ReducerState<Name>>(
  name: Name,
  state: State,
  action: FSA<*, *>,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialEndpointState,
      ...state[name],
      success: action.payload || null,
      isFetching: false,
      lastUpdate: Date.now(),
      lastResult: 'success',
    },
  }
);

export const handleSuccessKeyed = <Name: string, State: KeyedReducerState<Name>>(
  name: Name,
  state: State,
  action: FSA<*, *>,
  key: string,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialKeyedCollectionState,
      ...state[name],
      success: action.payload || null,
      isFetching: false,
      lastUpdate: Date.now(),
      lastResult: 'success',
      collection: handleKeyedCollection(key, state[name].collection, action.payload),
    },
  }
);

export const handleFailure = <Name: string, State: ReducerState<Name>>(
    name: Name,
    state: State,
    action: FSA<*, *>,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialEndpointState,
      ...state[name],
      failure: action.payload || null,
      isFetching: false,
      lastUpdate: Date.now(),
      lastResult: 'failure',
    },
  }
);

export const handleTimeout = <Name: string, State: ReducerState<Name>>(
    name: Name,
    state: State,
    action: FSA<*, *>,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialEndpointState,
      ...state[name],
      timeout: action.payload || null,
      isFetching: false,
      lastUpdate: Date.now(),
      lastResult: 'timeout',
    },
  }
);

export const handleMistake = <Name: string, State: ReducerState<Name>>(
    name: Name,
    state: State,
    action: FSA<*, *>,
  ): State => (
  {
    ...state,
    [name]: {
      ...initialEndpointState,
      ...state[name],
      mistake: action.payload || null,
      isFetching: false,
      lastUpdate: Date.now(),
      lastResult: 'mistake',
    },
  }
);