@scalar/api-client 0.5.1 → 0.5.2

package/src/helpers/sendRequest.ts

@@ -1,105 +0,0 @@
-import axios from 'axios'
-import { nanoid } from 'nanoid'
-
-import type {
-  ClientRequestConfig,
-  ClientResponse,
-  RequestResult,
-  SendRequestConfig,
-} from '../types'
-import {
-  concatenateUrlAndPath,
-  mapFromArray,
-  normalizePath,
-  normalizeRequestMethod,
-  normalizeUrl,
-  replaceVariables,
-} from './'
-
-const defaultHeaders = {
-  'User-Agent': 'Scalar API Client',
-}
-
-/**
- * Send a request via the proxy
- */
-export async function sendRequest(
-  request: SendRequestConfig,
-  proxyUrl?: string,
-): Promise<RequestResult | null> {
-  const method = normalizeRequestMethod(request.type)
-  const headers: Record<string, string | number> = {
-    ...defaultHeaders,
-    ...mapFromArray(request.headers ?? [], 'name', 'value'),
-  }
-  const url = normalizeUrl(request.url)
-  const path = normalizePath(request.path)
-  const urlWithPath = concatenateUrlAndPath(url, path)
-  const renderedURL = replaceVariables(
-    urlWithPath,
-    mapFromArray(request.parameters ?? [], 'name', 'value'),
-  )
-
-  /** TODO: Make dynamic */
-  const auth = {
-    type: 'none',
-  }
-
-  const startTime = Date.now()
-
-  const requestOptions = {
-    method,
-    url: renderedURL,
-    auth,
-    headers,
-    data: request.body,
-  }
-
-  const config = proxyUrl
-    ? {
-        method: 'POST',
-        url: proxyUrl,
-        data: requestOptions,
-      }
-    : {
-        method: requestOptions.method,
-        url: requestOptions.url,
-        headers: requestOptions.headers,
-        data: requestOptions.data,
-      }
-
-  console.info(`${requestOptions.method} ${requestOptions.url}`)
-
-  const response: (ClientResponse & { error: false }) | { error: true } =
-    // @ts-ignore
-    await axios(config)
-      .then((res) => {
-        return {
-          ...res.data,
-          error: false,
-        }
-      })
-      .catch((err) => {
-        return {
-          error: true,
-          ...err?.response,
-        }
-      })
-
-  return response.error
-    ? null
-    : {
-        sentTime: Date.now(),
-        request: {
-          ...request,
-          type: method,
-          url,
-          path,
-        },
-        response: {
-          ...response,
-          duration: Date.now() - startTime,
-        },
-        responseId: nanoid(),
-      }
-}

package/src/hooks/index.ts

@@ -1,2 +0,0 @@
-// export { useCopilot } from './useCopilot'
-export { useOperation, type ParamMap } from './useOperation'

package/src/hooks/useCopilot.ts

@@ -1,64 +0,0 @@
-import { useWebSocket } from '@vueuse/core'
-import { reactive, readonly } from 'vue'
-
-export enum CopilotLoadingStates {
-  Inactive = 'Inactive',
-  Fix = 'Fix',
-  Loading = 'Loading',
-  Working = 'Working',
-  Success = 'Success',
-}
-
-export type RequestData = {
-  id: string
-  request: string
-}
-export type RecommendationHandler = (recommendation: string) => void
-
-const recommendationHandler: Set<RecommendationHandler> = new Set([])
-
-function onMessage(_ws: WebSocket, event: MessageEvent) {
-  const jsonData = JSON.parse(event.data)
-  const recommendation = jsonData['response']
-  recommendationHandler.forEach((handler) => handler(recommendation))
-}
-
-const { send } = useWebSocket(import.meta.env.VITE_COPILOT_WS_URL, {
-  onMessage,
-  autoReconnect: true,
-})
-
-function sendCopilot(requestData: RequestData) {
-  setLoadingState(CopilotLoadingStates.Loading)
-  const jsonString = JSON.stringify(requestData)
-  send(jsonString)
-}
-
-const serverHandler = () => ({
-  uuid: '',
-  curlRequest:
-    "curl -X 'GET' 'https://petstore.swagger.io/v2/pet/findByStatus?status=SOld' -H 'accept: application/json'",
-})
-
-const serverHandlerState = reactive(serverHandler())
-
-const state = reactive({
-  loadingState: CopilotLoadingStates.Inactive,
-})
-
-function setLoadingState(loadingState: CopilotLoadingStates) {
-  state.loadingState = loadingState
-}
-
-/**
- * This hook is used to send requests to the copilot server and receive recommendations.
- */
-export const useCopilot = () => ({
-  sendCopilot,
-  state: readonly(state),
-  onRecommendation: (handler: RecommendationHandler) => {
-    recommendationHandler.add(handler)
-  },
-  serverHandlerState,
-  setLoadingState,
-})

package/src/hooks/useOperation.ts

@@ -1,43 +0,0 @@
-import { computed } from 'vue'
-
-import type { Operation, Parameters } from '../types'
-
-export type ParamMap = {
-  path: Parameters[]
-  query: Parameters[]
-  header: Parameters[]
-}
-
-export type OperationProps = {
-  operation: Operation
-}
-
-/**
- * This hook is used to generate the parameters for the request from the parameters in the swagger file
- */
-export function useOperation(props: OperationProps) {
-  const parameterMap = computed(() => {
-    const { parameters } = props.operation.information
-    const map: ParamMap = {
-      path: [],
-      query: [],
-      header: [],
-    }
-    if (parameters) {
-      parameters.forEach((parameter: Parameters) => {
-        if (parameter.in === 'path') {
-          map.path.push(parameter)
-        } else if (parameter.in === 'query') {
-          map.query.push(parameter)
-        } else if (parameter.in === 'header') {
-          map.header.push(parameter)
-        }
-      })
-    }
-    return map
-  })
-
-  return {
-    parameterMap,
-  }
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-export { ApiClient } from './components/ApiClient'
-
-export * from './helpers'
-export * from './hooks'
-export * from './stores/apiClientStore'
-export * from './stores/apiClientRequestStore'
-export * from './types'
-export * from './fixtures'

package/src/stores/apiClientRequestStore.ts

@@ -1,103 +0,0 @@
-import { computed, reactive, ref } from 'vue'
-
-import { createPlaceholderRequest } from '../helpers/createPlaceholderRequest'
-import type { AuthState, ClientRequestConfig, RequestResult } from '../types'
-
-// Auth state template
-export const createEmptyAuthState = (): AuthState => ({
-  type: 'none',
-  basic: {
-    userName: '',
-    password: '',
-    active: true,
-  },
-  oauthTwo: {
-    generatedToken: '',
-    discoveryURL: '',
-    authURL: '',
-    accessTokenURL: '',
-    clientID: '',
-    clientSecret: '',
-    scope: '',
-    active: true,
-  },
-  bearer: {
-    token: '',
-    active: true,
-  },
-  digest: {
-    userName: '',
-    password: '',
-    active: true,
-  },
-})
-
-/**
- * Request state
- */
-type RequestHistoryOrder = string[]
-type RequestHistoryEntry = RequestResult
-
-// Request Authorization State
-const authState = reactive(createEmptyAuthState())
-
-// Log of all requests made
-const requestHistory: Record<string, RequestHistoryEntry> = reactive({})
-
-// Request list order
-const requestHistoryOrder = ref<RequestHistoryOrder>([])
-
-// Id of the currently viewed request
-const activeRequestId = ref('')
-
-// Active request object
-const activeRequest = reactive(createPlaceholderRequest())
-
-/**
- * Mutators
- */
-
-// Add a new request to the history log and make it active
-const addRequestToHistory = (value: RequestHistoryEntry) => {
-  requestHistory[value.responseId] = value
-  activeRequestId.value = value.responseId
-  requestHistoryOrder.value.unshift(value.responseId)
-}
-
-// Set a response by key to currently active
-const setActiveResponse = (historyID: string) => {
-  activeRequestId.value = historyID
-  const { request }: { request: ClientRequestConfig } =
-    requestHistory[historyID]
-  Object.assign(activeRequest, request)
-}
-
-// Get the currently active response
-const activeResponse = computed(() =>
-  activeRequestId.value ? requestHistory[activeRequestId.value].response : null,
-)
-
-// Set the active request object
-const setActiveRequest = (request: ClientRequestConfig) => {
-  Object.assign(activeRequest, request)
-}
-
-/**
- * View state
- */
-
-// Whether the request is in read mode or edit mode
-const readOnly = ref(true)
-
-export const useApiClientRequestStore = () => ({
-  authState,
-  readOnly,
-  activeRequest,
-  activeResponse,
-  requestHistory,
-  requestHistoryOrder,
-  activeRequestId,
-  setActiveResponse,
-  addRequestToHistory,
-  setActiveRequest,
-})

package/src/stores/apiClientStore.ts

@@ -1,57 +0,0 @@
-import { reactive, readonly } from 'vue'
-
-type State = {
-  showApiClient: boolean
-  activeApiClientEndpointId: string
-  activeItem: any
-  snippetType: string
-  activeSidebar: string
-}
-
-function defaultState(): State {
-  return {
-    showApiClient: false,
-    activeApiClientEndpointId: '',
-    activeItem: {},
-    snippetType: 'javascript',
-    activeSidebar: '',
-  }
-}
-
-const state = reactive<State>(defaultState())
-
-function toggleApiClient(item?: any, forceShow = false) {
-  if (forceShow) {
-    state.showApiClient = true
-  } else {
-    state.showApiClient = !state.showApiClient
-  }
-  if (item) {
-    state.activeItem = item
-  }
-}
-
-function hideApiClient() {
-  state.showApiClient = false
-}
-
-function setActiveApiClientEndpointId(id: string) {
-  state.activeApiClientEndpointId = id
-}
-
-function setSnippetType(type: string) {
-  state.snippetType = type
-}
-
-function setActiveSidebar(item: string) {
-  state.activeSidebar = item
-}
-
-export const useApiClientStore = () => ({
-  state: readonly(state),
-  toggleApiClient,
-  setActiveApiClientEndpointId,
-  setSnippetType,
-  setActiveSidebar,
-  hideApiClient,
-})

package/src/stores/index.ts

@@ -1,5 +0,0 @@
-export { useApiClientStore } from './apiClientStore'
-export {
-  useApiClientRequestStore,
-  createEmptyAuthState,
-} from './apiClientRequestStore'

package/src/types.ts

@@ -1,185 +0,0 @@
-export type BasicAuth = {
-  userName: string
-  password: string
-  active: boolean
-}
-
-export type OAuthTwo = {
-  generatedToken: string
-  discoveryURL: string
-  authURL: string
-  accessTokenURL: string
-  clientID: string
-  clientSecret: string
-  scope: string
-  active: boolean
-}
-
-export type Bearer = {
-  token: string
-  active: boolean
-}
-
-export type Digest = {
-  userName: string
-  password: string
-  active: boolean
-}
-
-export type AuthType = 'basic' | 'oauthTwo' | 'bearer' | 'digest' | 'none'
-
-export type AuthState = {
-  type: AuthType
-  basic: BasicAuth
-  oauthTwo: OAuthTwo
-  bearer: Bearer
-  digest: Digest
-}
-
-export type BaseParameter = {
-  name: string
-  value: string | number
-  customClass?: string
-}
-
-export type Header = BaseParameter
-
-export type Query = BaseParameter
-
-export type FormDataItem = BaseParameter
-
-/** Complete request state for a client request */
-export type ClientRequestConfig = {
-  id?: string
-  name?: string
-  url: string
-  /** HTTP Request Method */
-  type: string
-  /** Request path */
-  path: string
-  /** TODO: Rename to variables? */
-  /** Path parameters */
-  parameters?: BaseParameter[]
-  /** Query parameters */
-  query?: Query[]
-  /** Request headers */
-  headers?: Header[]
-  /** Content type matched body */
-  body?: string
-  /** Optional form data body */
-  formData?: FormDataItem[]
-}
-
-/** Formatted request for the proxy server */
-export type ProxyPayload = {
-  method: string
-  url: string
-  body: string
-  headers: Header[]
-  auth: Record<string, string>
-  grpc: boolean
-}
-
-/** Client response from the proxy */
-export type ClientResponse = {
-  cookies: Record<string, string>
-  headers: Record<string, string>
-  statusCode: number
-  statusText: string
-  data: string
-  duration: number
-}
-
-export type SendRequestConfig = Partial<ClientRequestConfig> &
-  Required<Pick<ClientRequestConfig, 'url'>>
-
-export type RequestResult = {
-  request: ClientRequestConfig
-  response: ClientResponse
-  responseId: string
-  sentTime: number
-}
-
-export type Schema = {
-  format: string
-  type: string
-}
-
-export type Parameters = {
-  description?: string
-  in?: string
-  name: string
-  required?: boolean
-  schema?: Schema
-}
-
-export type Security = {
-  api_key?: any[]
-  petstore_auth?: string[]
-}
-
-export type ContentProperties = {
-  [key: string]: {
-    type: string
-    format: string
-    example: string
-    required: string[]
-    description?: string
-    properties?: ContentProperties
-  }
-}
-
-export type ContentSchema = {
-  schema: {
-    type: string
-    required: string[]
-    properties: ContentProperties
-  }
-}
-
-export type ContentType =
-  | 'application/json'
-  | 'application/xml'
-  | 'text/plain'
-  | 'text/html'
-  | 'application/x-www-form-urlencoded'
-  | 'multipart/form-data'
-
-export type Content = {
-  [key in ContentType]: ContentSchema
-}
-
-export type RequestBody = {
-  description: string
-  content: Content
-  required: boolean
-}
-
-export type Response = {
-  description: string
-  content: any
-}
-
-export type Information = {
-  description: string
-  operationId: string
-  parameters: Parameters[]
-  responses: Record<string, Response>
-  security: Security[]
-  requestBody: RequestBody
-  summary: string
-  tags: string[]
-}
-
-export type Operation = {
-  httpVerb: string
-  path: string
-  operationId: string
-  name: string
-  description: string
-  information: Information
-}
-
-export type Server = {
-  url: string
-}