@stacksjs/api 0.64.6 → 0.65.0

package/dist/ofetch.d.ts

@@ -0,0 +1,17 @@
+interface Params {
+	[key: string]: any;
+}
+interface ApiFetch {
+	get: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>;
+	post: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>;
+	destroy: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>;
+	patch: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>;
+	put: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>;
+	setToken: (authToken: string) => void;
+	baseURL: "/" | string;
+	loading: boolean;
+	token: string;
+}
+type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>;
+export declare const Fetch: ApiFetch;
+export {};

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "@stacksjs/api",
   "type": "module",
-  "version": "0.64.6",
+  "version": "0.65.0",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/arrays#readme",
@@ -38,23 +36,19 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
+    "build": "bun build.ts",
     "generate-types": "openapi-typescript ./../../api/openapi.json --output ./../../api/api-types.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/utils": "latest",
-    "ofetch": "^1.3.4",
-    "openapi-typescript": "^7.3.0"
+    "@stacksjs/utils": "0.64.6",
+    "ofetch": "^1.4.1",
+    "openapi-typescript": "^7.4.1"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/development": "0.64.6"
   }
 }

package/src/generate-openapi.ts

@@ -1,7 +1,7 @@
 import { path } from '@stacksjs/path'
 import { route } from '@stacksjs/router'
 
-async function generateOpenAPISpec() {
+export async function generateOpenApi(): Promise<void> {
   const routeLists: any[] = await route.getRoutes()
 
   const openAPISpec = {
@@ -15,17 +15,15 @@ async function generateOpenAPISpec() {
       schemas: {} as Record<string, any>,
     },
   }
-
   routeLists.forEach((route) => {
-    const path = route.url.replace(/{([^}]+)}/g, '{$1}')
+    const path = route.url.replace(/\{([^}]+)\}/g, '{$1}')
     if (!openAPISpec.paths[path]) {
       openAPISpec.paths[path] = {}
     }
-
     openAPISpec.paths[path][route.method.toLowerCase()] = {
       summary: route.name,
       operationId: route.callback,
-      parameters: route.paramNames.map((param) => ({
+      parameters: route.paramNames.map((param: string) => ({
         name: param,
         in: 'path',
         required: true,
@@ -47,7 +45,6 @@ async function generateOpenAPISpec() {
         },
       },
     }
-
     // Add schemas to components if they are not already defined
     if (route.responseSchema) {
       const schemaName = `${route.name.replace(/\./g, '')}Response`
@@ -58,7 +55,6 @@ async function generateOpenAPISpec() {
         $ref: `#/components/schemas/${schemaName}`,
       }
     }
-
     if (route.requestSchema) {
       const schemaName = `${route.name.replace(/\./g, '')}Request`
       openAPISpec.components.schemas[schemaName] = route.requestSchema
@@ -68,15 +64,10 @@ async function generateOpenAPISpec() {
     }
   })
 
-  return openAPISpec
-}
+  const file = Bun.file(path.frameworkPath(`api/openapi.json`))
+  const writer = file.writer()
 
-const openAPISpec = await generateOpenAPISpec()
+  writer.write(JSON.stringify(openAPISpec))
 
-const file = Bun.file(path.frameworkPath(`api/openapi.json`))
-
-const writer = file.writer()
-
-writer.write(JSON.stringify(openAPISpec.toString()))
-
-await writer.end()
+  await writer.end()
+}

package/src/index.ts

@@ -1,149 +1,2 @@
-import { ofetch } from 'ofetch'
-
-interface Params {
-  [key: string]: any // Replace 'any' with more specific types if possible
-}
-
-interface FetchRequestHeaders {
-  'Content-Type'?: string
-  Authorization?: string
-  Accept?: string
-  'User-Agent'?: string
-  Referer?: string
-  Origin?: string
-  'Cache-Control'?: string
-  Pragma?: string
-  Cookie?: string
-  'If-Modified-Since'?: string
-  'If-None-Match'?: string
-  'X-Requested-With'?: string
-  'Accept-Encoding'?: string
-  'Accept-Language'?: string
-  [key: string]: string | undefined // To allow additional headers
-}
-
-interface FetchRequestParams {
-  headers?: FetchRequestHeaders
-  method?: string
-  baseURL?: string
-  body?: any // Optional, for request bodies like in POST or PUT requests
-  mode?: RequestMode // Optional, e.g., 'cors', 'no-cors', 'same-origin'
-  credentials?: RequestCredentials // Optional, e.g., 'include', 'same-origin', 'omit'
-  cache?: RequestCache // Optional, e.g., 'default', 'no-store', 'reload'
-  redirect?: RequestRedirect // Optional, e.g., 'follow', 'manual', 'error'
-  referrerPolicy?: ReferrerPolicy // Optional, e.g., 'no-referrer', 'origin'
-  integrity?: string // Optional, for subresource integrity
-  keepalive?: boolean // Optional, for whether the request should outlive the page
-  signal?: AbortSignal // Optional, to abort the request
-  [key: string]: any // To allow additional parameters
-}
-
-type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
-
-const loading = ref(false)
-const token = ref('')
-const baseURL = '/'
-
-async function post(url: string, params?: Params): Promise<any> {
-  const headers: FetchRequestHeaders = { Accept: 'application/json' }
-
-  if (token.value) headers.Authorization = `Bearer ${token.value}`
-
-  const parameters: FetchRequestParams = {
-    ...params,
-    ...{
-      headers,
-      parseResponse: JSON.parse,
-      method: 'POST',
-      baseURL,
-    },
-  }
-
-  loading.value = true
-
-  try {
-    const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(
-      url,
-      parameters,
-    )
-
-    loading.value = false
-    return result
-  } catch (err: any) {
-    loading.value = false
-
-    throw err
-  }
-}
-
-async function get(url: string, params?: Params): Promise<any> {
-  const headers: FetchRequestHeaders = { Accept: 'application/json' }
-
-  if (token.value) headers.Authorization = `Bearer ${token.value}`
-
-  const parameters: FetchRequestParams = {
-    ...params,
-    ...{
-      headers,
-      parseResponse: JSON.parse,
-      method: 'GET',
-      baseURL,
-    },
-  }
-
-  return (await ofetch(url, parameters)) as FetchResponse
-}
-
-async function patch(url: string, params?: Params): Promise<any> {
-  const headers: FetchRequestHeaders = { Accept: 'application/json' }
-
-  if (token.value) headers.Authorization = `Bearer ${token.value}`
-
-  const parameters: FetchRequestParams = {
-    ...params,
-    ...{
-      headers,
-      parseResponse: JSON.parse,
-      method: 'PATCH',
-      baseURL,
-    },
-  }
-
-  loading.value = true
-
-  return (await ofetch(url, parameters)) as FetchResponse
-}
-
-async function destroy(url: string, params?: Params): Promise<any> {
-  const headers: FetchRequestHeaders = { Accept: 'application/json' }
-
-  if (token.value) headers.Authorization = `Bearer ${token.value}`
-
-  const parameters: FetchRequestParams = {
-    ...params,
-    ...{
-      headers,
-      method: 'DELETE',
-      baseURL,
-    },
-  }
-
-  loading.value = true
-
-  return (await ofetch(url, parameters)) as FetchResponse
-}
-
-function setToken(authToken: string) {
-  token.value = authToken
-}
-
-export const Fetch = {
-  post,
-  get,
-  patch,
-  destroy,
-  baseURL,
-  loading,
-  token,
-  setToken,
-}
+export * from './generate-openapi'
+export * from './ofetch'

package/src/ofetch.ts

@@ -0,0 +1,122 @@
+import { ofetch } from 'ofetch'
+
+interface Params {
+  [key: string]: any // Replace 'any' with more specific types if possible
+}
+
+interface ApiFetch {
+  get: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  post: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  destroy: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  patch: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  put: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
+  setToken: (authToken: string) => void
+  baseURL: '/' | string
+  loading: boolean
+  token: string
+}
+
+type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
+
+let loading = false
+let token = ''
+const baseURL = '/'
+
+async function get(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  return await ofetch(url, { method: 'GET', baseURL, params, headers })
+}
+
+async function post(url: string, params?: Params, headers?: Headers): Promise<any> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  try {
+    const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(url, {
+      method: 'POST',
+      baseURL,
+      params,
+      headers,
+    })
+
+    loading = false
+    return result
+  }
+  catch (err: any) {
+    loading = false
+
+    throw err
+  }
+}
+
+async function patch(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'PATCH',
+    baseURL,
+    params,
+    headers,
+  })
+}
+
+async function put(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'PUT',
+    baseURL,
+    params,
+    headers,
+  })
+}
+
+async function destroy(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
+  if (headers) {
+    if (token)
+      headers.set('Authorization', `Bearer ${token}`)
+  }
+
+  loading = true
+
+  return await ofetch(url, {
+    method: 'DELETE',
+    baseURL,
+    params,
+    headers,
+  })
+}
+
+function setToken(authToken: string): void {
+  token = authToken
+}
+
+export const Fetch: ApiFetch = {
+  get,
+  post,
+  patch,
+  put,
+  destroy,
+  baseURL,
+  token,
+  setToken,
+  loading,
+}