@digi-frontend/dgate-api-documentation 1.0.39 → 1.0.50

package/src/constants/index.ts

@@ -1,93 +1,95 @@
-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: '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 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,
+]

package/src/constants/methods.constant.ts

@@ -0,0 +1,26 @@
+export type MethodOption = {
+  label: string
+  value: string
+  color: string
+}
+
+export const METHOD_OPTIONS: MethodOption[] = [
+  { label: 'Post', value: 'POST', color: '#10b981' },
+  { label: 'GET', value: 'GET', color: '#3b82f6' },
+  { label: 'Delete', value: 'DELETE', color: '#ef4444' },
+  { label: 'Put', value: 'PUT', color: '#f59e0b' },
+  { label: 'PATCH', value: 'PATCH', color: '#C0F4E8' },
+  { label: 'OPTIONS', value: 'OPTIONS', color: '#6b7280' },
+  { label: 'HEAD', value: 'HEAD', color: '#8b5cf6' },
+  { label: 'TRACE', value: 'TRACE', color: '#ec4899' },
+]
+
+export const METHOD_OPTIONS_CONFIG = [
+  {
+    list: METHOD_OPTIONS.map((method) => ({
+      labelConfig: { color: method.color, text: method.label },
+      value: method.value,
+      data: method,
+    })),
+  },
+]

package/src/constants/regex.ts

@@ -1,7 +1,7 @@
-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
+  ASCII: /^[\x00-\x7F]+$/,
+  urlRegex: /^(https?:\/\/|www\.)[a-zA-Z0-9-]+(\.[a-zA-Z]{2,})+(\/[^\s]*)?$/,
+}
+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/docs.helper.ts

@@ -0,0 +1,28 @@
+import { HTTPMethod, OpenAPIFile } from '@entities/openApi'
+import { nanoid } from 'nanoid'
+import { OverviewData, TagData } from 'src/layout/docsLayout'
+
+export const transformOpenApiToDocs = (openApiJson: OpenAPIFile): OverviewData => {
+  const groupedPathsByTags: Record<string, TagData[]> = { default: [] }
+  const validTags = new Set(openApiJson.tags.map(({ name }) => name))
+
+  for (const [path, methods] of Object.entries(openApiJson.paths)) {
+    for (const [method, methodData] of Object.entries(methods)) {
+      const entry = { ...methodData, method: method as HTTPMethod, path }
+      const resourceTags = methodData.tags ?? []
+
+      const matchedTags = resourceTags.filter((tag) => validTags.has(tag))
+
+      if (matchedTags.length > 0) {
+        matchedTags.forEach((tag) => {
+          if (!groupedPathsByTags[tag]) groupedPathsByTags[tag] = []
+          groupedPathsByTags[tag].push({ ...entry, id: nanoid(8) } as TagData)
+        })
+      } else {
+        groupedPathsByTags.default.push({ ...entry, id: nanoid(8) } as TagData)
+      }
+    }
+  }
+
+  return { ...openApiJson.info, id: nanoid(8), tags: groupedPathsByTags }
+}

package/src/helpers/layout.helper.ts

@@ -1,174 +1,176 @@
-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']
-    }
-  } 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.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),
-              },
-            },
-          }
-        }),
-      }
-      // Add parameters if it does not exist in the original JSON
-      if (!methodProps?.parameters) {
-        obj.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) => {
-  let _content = JSON.parse((content?.schema as any)?.properties as string)
-  // if (method == 'get') {
-  //   if (!_content?.body) {
-  //     _content = {
-  //       body: _content,
-  //     }
-  //   }
-  // }
-  return _content
-}
-
-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: validateBodyForResponse(content, type),
-                    },
-                  },
-                }
-              : {},
-          }
-          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 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]
+          return {
+            code,
+            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 = []
+      }
+
+      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) => {
+  let _content = JSON.parse((content?.schema as any)?.properties as string)
+  // if (method == 'get') {
+  //   if (!_content?.body) {
+  //     _content = {
+  //       body: _content,
+  //     }
+  //   }
+  // }
+  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 }) => {
+            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),
+                      },
+                    },
+                  }
+                : {},
+            }
+            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'])
+}