@digi-frontend/dgate-api-documentation 1.0.1 → 1.0.5

package/src/constants/index.ts

@@ -1,95 +1,74 @@
-export const methodColorMapping = {
-  get: {
-    label: 'Get',
-    color: '#3A6CD1',
-    order: 1,
-  },
-  post: {
-    label: 'Post',
-    color: '#3AAA35',
-    order: 2,
-  },
-  put: {
-    label: 'Put',
-    color: '#FAAD14',
-    order: 3,
-  },
-  delete: {
-    label: 'Delete',
-    color: '#DA3F3F',
-    order: 4,
-  },
-  patch: {
-    label: 'Patch',
-    color: '#58E2C2',
-    order: 5,
-  },
-  options: {
-    label: 'Options',
-    color: '#495D97',
-    order: 6,
-  },
-  trace: {
-    label: 'Trace',
-    color: '#FFA28F',
-    order: 7,
-  },
-  head: {
-    label: 'Head',
-    color: '#9461C9',
-    order: 8,
-  },
-}
-
-export const tagsTableHeaders = [
-  {
-    id: 'tagName',
-    label: 'Tag Name',
-    sortable: false,
-    classes: 'requiredParam',
-  },
-  {
-    id: 'description',
-    label: 'Description',
-    sortable: false,
-  },
-  {
-    id: 'externalDocs',
-    label: 'External Docs',
-    sortable: false,
-  },
-]
-
-export const paramsTableHeaders = [
-  {
-    id: 'paramName',
-    label: 'Parameter Name',
-    sortable: false,
-    required: true,
-    classes: 'requiredParam',
-  },
-  { id: 'paramType', label: 'In', sortable: false, classes: 'requiredParam' },
-  { id: 'schemaType', label: 'Schema-Type', sortable: false, classes: 'requiredParam' },
-  // { id: 'arraySchemaType', label: 'Array Schema Type', sortable: false },
-  { id: 'enum', label: 'Enum', sortable: false },
-  { id: 'required', label: 'Required', sortable: false, classes: 'requiredParam' },
-  { id: 'description', label: 'Description', sortable: false },
-]
-
-export const httpStatusCodes = [
-  // 1xx: Informational responses
-  100, 101, 102, 103,
-
-  // 2xx: Success
-  200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
-
-  // 3xx: Redirection
-  300, 301, 302, 303, 304, 305, 306, 307, 308,
-
-  // 4xx: Client errors
-  400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418,
-  421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
-
-  // 5xx: Server errors
-  500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
-]
+export const methodColorMapping = {
+  get: {
+    label: 'Get',
+    color: '#3A6CD1',
+    order: 1,
+  },
+  post: {
+    label: 'Post',
+    color: '#3AAA35',
+    order: 2,
+  },
+  put: {
+    label: 'Put',
+    color: '#FAAD14',
+    order: 3,
+  },
+  delete: {
+    label: 'Delete',
+    color: '#DA3F3F',
+    order: 4,
+  },
+  patch: {
+    label: 'Patch',
+    color: '#58E2C2',
+    order: 5,
+  },
+  options: {
+    label: 'Options',
+    color: '#495D97',
+    order: 6,
+  },
+  trace: {
+    label: 'Trace',
+    color: '#FFA28F',
+    order: 7,
+  },
+  head: {
+    label: 'Head',
+    color: '#9461C9',
+    order: 8,
+  },
+}
+
+export const paramsTableHeaders = [
+  {
+    id: 'paramName',
+    label: 'Parameter Name',
+    sortable: false,
+    required: true,
+    classes: 'requiredParam',
+  },
+  { id: 'paramType', label: 'In', sortable: false, classes: 'requiredParam' },
+  { id: 'schemaType', label: 'Schema-Type', sortable: false, classes: 'requiredParam' },
+  { id: 'required', label: 'Required', sortable: false, classes: 'requiredParam' },
+  { id: 'description', label: 'Description', sortable: false },
+]
+
+export const httpStatusCodes = [
+  // 1xx: Informational responses
+  100, 101, 102, 103,
+
+  // 2xx: Success
+  200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+
+  // 3xx: Redirection
+  300, 301, 302, 303, 304, 305, 306, 307, 308,
+
+  // 4xx: Client errors
+  400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418,
+  421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
+
+  // 5xx: Server errors
+  500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+]

package/src/constants/regex.ts

@@ -1,7 +1,5 @@
-const regex = {
-  basic: /[^a-zA-Z0-9-_ ]/, // not (alphanumeric + underscore + dash + space)
-  restrictNone: /^$/, // restrict nothing
-  ASCII: /^[\x00-\x7F]+$/,
-  urlRegex: /^(https?:\/\/|www\.)[a-zA-Z0-9-]+(\.[a-zA-Z]{2,})+(\/[^\s]*)?$/,
-}
-export default regex
+const regex = {
+  basic: /[^a-zA-Z0-9-_ ]/, // not (alphanumeric + underscore + dash + space)
+  restrictNone: /^$/, // restrict nothing
+}
+export default regex

package/src/global.d.ts

@@ -1,13 +1,13 @@
-declare module '*.module.css' {
-  const classes: { [key: string]: string }
-  export default classes
-}
-declare module '*.module.scss' {
-  const classes: { [key: string]: string }
-  export default classes
-}
-
-declare module '*.svg' {
-  const src: string
-  export default src
-}
+declare module '*.module.css' {
+  const classes: { [key: string]: string }
+  export default classes
+}
+declare module '*.module.scss' {
+  const classes: { [key: string]: string }
+  export default classes
+}
+
+declare module '*.svg' {
+  const src: string
+  export default src
+}

package/src/helpers/layout.helper.ts

@@ -1,187 +1,147 @@
-import { TransformedPathsArray } from '@entities/layout.type'
-import { OpenAPIFile, SecurityScheme } from '@entities/openApi'
-import { TransformedOpenApi } from '@entities/transformedOpenApi'
-
-export const transformOpenApiObject = (openApiJson: OpenAPIFile): TransformedOpenApi => {
-  if (openApiJson.components && openApiJson.components.securitySchemes) {
-    const authKey = Object.keys(openApiJson.components.securitySchemes)?.at(0)
-    if (authKey) {
-      openApiJson.components.securitySchemes[authKey].type = openApiJson?.components
-        ?.securitySchemes?.[authKey]?.type as SecurityScheme['type']
-    }
-  } else {
-    openApiJson.components = {
-      securitySchemes: {
-        Public: {
-          type: 'http',
-          scheme: 'public',
-        },
-      },
-    }
-  }
-
-  if (!openApiJson.tags) {
-    openApiJson.tags = []
-  }
-
-  return {
-    ...openApiJson,
-    paths: transformPathsToArray(openApiJson.paths),
-  } as TransformedOpenApi
-}
-
-export const transformOpenApiObjectToOrigin = (values: TransformedOpenApi): OpenAPIFile => {
-  const object = {
-    ...values,
-    paths: transformPathsArrayToOrigin(values.paths),
-  }
-  if (object.components && object.components.securitySchemes) {
-    const authKey = Object.keys(object.components.securitySchemes)?.at(0)
-    if (authKey) {
-      if (object.components.securitySchemes[authKey].type.toLowerCase() == 'APIKEY'.toLowerCase()) {
-        object.components.securitySchemes[authKey].in = object.components.securitySchemes[authKey]
-          .in as SecurityScheme['in']
-      }
-      object.components.securitySchemes[authKey].type = object?.components?.securitySchemes?.[
-        authKey
-      ]?.type as SecurityScheme['type']
-    }
-  }
-  return object
-}
-
-export const transformPathsToArray = (paths: OpenAPIFile['paths']): TransformedPathsArray | any => {
-  const transformedPaths = Object.entries(paths).map(([path, methods]) => ({
-    path,
-    methods: Object.entries(methods).map(([method, methodProps]) => {
-      const obj: any = {
-        ...methodProps,
-        type: method,
-        tags: methodProps.tags || [],
-        summary: methodProps.summary || '',
-        responses: Object.entries(methodProps.responses).map(([code, codeProps]) => {
-          const contentType = Object.keys(codeProps.content || {})[0]
-          const headers = !codeProps?.headers ? {} : codeProps.headers
-          return {
-            code,
-            headers,
-            content: {
-              contentType,
-              schema: {
-                ...codeProps.content?.[contentType]?.schema,
-                properties: JSON.stringify(codeProps.content?.[contentType]?.schema?.properties),
-              },
-            },
-          }
-        }),
-      }
-      // Add parameters if it does not exist in the original JSON
-      if (!methodProps?.parameters) {
-        obj.parameters = []
-      }
-
-      // load response headers parameters
-
-      if (method.toLowerCase() != 'get') {
-        const contentType = Object.keys(methodProps?.requestBody?.content || {})[0]
-        const reqSchema = methodProps?.requestBody?.content?.schema
-        const requestBodyData = methodProps?.requestBody?.content?.schema?.properties
-          ? {
-              content: {
-                contentType,
-                schema: {
-                  ...reqSchema,
-                  properties: reqSchema?.properties ? JSON.stringify(reqSchema?.properties) : '{}',
-                },
-              },
-            }
-          : {
-              content: {
-                contentType: 'application/json',
-                schema: {
-                  properties: '{}',
-                  type: 'object',
-                },
-              },
-            }
-
-        obj['requestBody'] = requestBodyData
-      }
-      return obj
-    }),
-  }))
-
-  return transformedPaths
-}
-
-const validateBodyForResponse = (content, method) => {
-  if (!(content?.schema as any) || !(content?.schema as any)?.properties) {
-    return {}
-  }
-  let _content = JSON.parse((content?.schema as any)?.properties as string)
-
-  return _content
-}
-
-export const transformPathsArrayToOrigin = (paths: TransformedPathsArray): OpenAPIFile['paths'] => {
-  return paths.reduce((acc, { path, methods }) => {
-    acc[path] = methods.reduce(
-      (methodAcc, { type, tags, responses, summary, requestBody, ...rest }) => {
-        // Initialize the method object
-        methodAcc[type] = {
-          ...rest,
-          tags,
-          summary,
-          responses: responses.reduce((respAcc, { code, content, headers }) => {
-            const formattedHeaders: Record<string, any> = {}
-            if (headers) {
-              for (const [key, value] of Object.entries(headers)) {
-                formattedHeaders[key] = {
-                  description: value.description || '',
-                  required: value.required || false,
-                  schema: value.schema || {},
-                }
-              }
-            }
-            respAcc[code] = {
-              description: 'Success', // Assuming this is static from the original data
-              content: content.contentType
-                ? {
-                    [content.contentType]: {
-                      schema: {
-                        ...(content.schema as object),
-                        properties: validateBodyForResponse(content, type),
-                      },
-                    },
-                  }
-                : {},
-              headers: formattedHeaders,
-            }
-            return respAcc
-          }, {} as Record<string, any>),
-        }
-
-        const parsedRequestBodyProps =
-          type !== 'get' ? JSON.parse(requestBody.content.schema.properties) : {}
-        // Add requestBody for non-GET methods
-        if (type !== 'get') {
-          methodAcc[type].requestBody = {
-            content: {
-              [requestBody.content.contentType]: {
-                schema: {
-                  ...requestBody.content.schema,
-                  properties: parsedRequestBodyProps,
-                },
-              },
-            },
-          }
-        }
-
-        return methodAcc
-      },
-      {} as Record<string, any>
-    )
-
-    return acc
-  }, {} as OpenAPIFile['paths'])
-}
+import { TransformedPathsArray } from '@entities/layout.type'
+import { OpenAPIFile, SecurityScheme } from '@entities/openApi'
+import { TransformedOpenApi } from '@entities/transformedOpenApi'
+
+export const transformOpenApiObject = (openApiJson: OpenAPIFile): TransformedOpenApi => {
+  if (openApiJson.components && openApiJson.components.securitySchemes) {
+    const authKey = Object.keys(openApiJson.components.securitySchemes)?.at(0)
+
+    if (authKey) {
+      openApiJson.components.securitySchemes[authKey].type =
+        openApiJson?.components?.securitySchemes?.[
+          authKey
+        ]?.type?.toUpperCase() as SecurityScheme['type']
+    }
+  }
+
+  return {
+    ...openApiJson,
+    paths: transformPathsToArray(openApiJson.paths),
+  } as TransformedOpenApi
+}
+
+export const transformOpenApiObjectToOrigin = (values: TransformedOpenApi): OpenAPIFile => {
+  const object = {
+    ...values,
+    paths: transformPathsArrayToOrigin(values.paths),
+  }
+  if (object.components && object.components.securitySchemes) {
+    const authKey = Object.keys(object.components.securitySchemes)?.at(0)
+    if (authKey) {
+      if (object.components.securitySchemes[authKey].type.toLowerCase() == 'APIKEY'.toLowerCase()) {
+        object.components.securitySchemes[authKey].in = object.components.securitySchemes[
+          authKey
+        ].in.toUpperCase() as SecurityScheme['in']
+      }
+      object.components.securitySchemes[authKey].type = object?.components?.securitySchemes?.[
+        authKey
+      ]?.type?.toUpperCase() as SecurityScheme['type']
+    }
+  }
+  return object
+}
+
+export const transformPathsToArray = (paths: OpenAPIFile['paths']): TransformedPathsArray | any => {
+  const transformedPaths = Object.entries(paths).map(([path, methods]) => ({
+    path,
+    methods: Object.entries(methods).map(([method, methodProps]) => {
+      const obj: any = {
+        ...methodProps,
+        type: method,
+        tags: methodProps.tags,
+        responses: Object.entries(methodProps.responses).map(([code, codeProps]) => {
+          const contentType = Object.keys(codeProps.content || {})[0]
+          return {
+            code,
+            content: {
+              contentType,
+              schema: {
+                ...codeProps.content?.[contentType]?.schema,
+                properties: JSON.stringify(codeProps.content?.[contentType]?.schema?.properties),
+              },
+            },
+          }
+        }),
+      }
+
+      if (method.toLowerCase() != 'get') {
+        obj['requestBody'] = methodProps.requestBody
+          ? Object.entries(methodProps.requestBody).map(([_, codeProps]) => {
+              const contentType = Object.keys(codeProps.content || {})[0]
+              return {
+                content: {
+                  contentType,
+                  schema: {
+                    ...codeProps.content?.[contentType]?.schema,
+                    properties: JSON.stringify(
+                      codeProps.content?.[contentType]?.schema?.properties
+                    ),
+                  },
+                },
+              }
+            })
+          : [
+              {
+                content: {
+                  contentType: 'application/json',
+                  schema: {
+                    properties: '{}',
+                    type: 'object',
+                  },
+                },
+              },
+            ]
+      }
+      return obj
+    }),
+  }))
+  return transformedPaths
+}
+
+export const transformPathsArrayToOrigin = (paths: TransformedPathsArray): OpenAPIFile['paths'] => {
+  return paths.reduce((acc, { path, methods }) => {
+    acc[path] = methods.reduce((methodAcc, { type, tags, responses, requestBody, ...rest }) => {
+      // Initialize the method object
+      methodAcc[type] = {
+        ...rest,
+        tags,
+        responses: responses.reduce((respAcc, { code, content }) => {
+          respAcc[code] = {
+            description: 'Success', // Assuming this is static from the original data
+            content: content.contentType
+              ? {
+                  [content.contentType]: {
+                    schema: {
+                      ...(content.schema as object),
+                      properties: JSON.parse((content?.schema as any)?.properties as string),
+                    },
+                  },
+                }
+              : {},
+          }
+          return respAcc
+        }, {} as Record<string, any>),
+      }
+
+      const parsedRequestBodyProps =
+        type !== 'get' ? JSON.parse(requestBody[0].content.schema.properties) : {}
+      // Add requestBody for non-GET methods
+      if (type !== 'get') {
+        methodAcc[type].requestBody = {
+          content: {
+            [requestBody[0].content.contentType]: {
+              schema: {
+                ...requestBody[0].content.schema,
+                properties: parsedRequestBodyProps,
+              },
+            },
+          },
+        }
+      }
+
+      return methodAcc
+    }, {} as Record<string, any>)
+
+    return acc
+  }, {} as OpenAPIFile['paths'])
+}

package/src/helpers/methodAccordion.helper.ts

@@ -1,20 +1,20 @@
-export const handleStatusColor = (code: number): string => {
-  if (code >= 200 && code < 300) {
-    return 'green' // 2xx codes
-  } else if (code >= 400 && code < 500) {
-    return 'red' // 4xx codes
-  } else if (code >= 500 && code < 600) {
-    return 'red' // 5xx codes
-  } else if (code >= 100 && code < 200) {
-    return 'blue' // 1xx codes (Informational)
-  } else if (code >= 300 && code < 400) {
-    return 'orange' // 3xx codes (Redirection)
-  } else {
-    return 'gray' // Default or invalid status codes
-  }
-}
-
-export const  capitalize = (str)=> {
-  if (!str) return "";
-  return str.charAt(0).toUpperCase() + str.slice(1);
+export const handleStatusColor = (code: number): string => {
+  if (code >= 200 && code < 300) {
+    return 'green' // 2xx codes
+  } else if (code >= 400 && code < 500) {
+    return 'red' // 4xx codes
+  } else if (code >= 500 && code < 600) {
+    return 'red' // 5xx codes
+  } else if (code >= 100 && code < 200) {
+    return 'blue' // 1xx codes (Informational)
+  } else if (code >= 300 && code < 400) {
+    return 'orange' // 3xx codes (Redirection)
+  } else {
+    return 'gray' // Default or invalid status codes
+  }
+}
+
+export const  capitalize = (str)=> {
+  if (!str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }

package/src/index.ts

@@ -1,2 +1 @@
-export { default as Layout } from './layout/layout'
-export { default as DocsLayout } from './layout/docsLayout'
+export { default as Layout } from './layout/layout'