@safagayret/bemirror 1.0.0

package/server.js

@@ -0,0 +1,322 @@
+const express = require('express')
+const cors = require('cors')
+const path = require('path')
+const fs = require('fs')
+
+const slugify = (str) => {
+  if (!str) return 'unknown'
+  return str
+    .toString()
+    .replace(/([a-z])([A-Z])/g, '$1-$2') // CamelCase / PascalCase to kebab-case
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+}
+
+const replaceVariables = (str, vars) => {
+  if (!str || typeof str !== 'string') return str
+  return str.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+    return vars[key] !== undefined ? vars[key] : match
+  })
+}
+
+const getDefaultData = () => ({ projects: [] })
+const isPostPutPatch = (method) => ['POST', 'PUT', 'PATCH'].includes(method)
+const isGetDelete = (method) => ['GET', 'DELETE'].includes(method)
+
+const loadJsonFile = (filePath, defaultValue) => {
+  try {
+    if (fs.existsSync(filePath)) {
+      const fileContent = fs.readFileSync(filePath, 'utf-8')
+      return JSON.parse(fileContent)
+    }
+  } catch (err) {
+    console.warn(`Failed to load ${path.basename(filePath)}, starting with default state:`, err.message)
+  }
+  return defaultValue
+}
+
+const saveJsonFile = (filePath, data) => {
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8')
+  } catch (err) {
+    console.error(`Failed to write ${path.basename(filePath)}:`, err.message)
+  }
+}
+
+const createBemirrorApp = (options = {}) => {
+  const ENDPOINTS_FILE = options.endpointsFile || path.join(__dirname, 'endpoints.json')
+  const VARIABLES_FILE = options.variablesFile || path.join(__dirname, 'variables.json')
+  const PUBLIC_DIR = options.publicDir || path.join(__dirname, 'public')
+
+  const app = express()
+  app.use(cors())
+  app.use(express.json({ limit: '10mb' }))
+  app.use(express.static(PUBLIC_DIR))
+
+  let memoryDb = getDefaultData()
+  let variables = {}
+
+  const getData = () => memoryDb
+  const saveData = (data) => {
+    memoryDb = data
+    saveJsonFile(ENDPOINTS_FILE, data)
+  }
+
+  const getVariables = () => variables
+  const saveVariables = (data) => {
+    variables = data
+    saveJsonFile(VARIABLES_FILE, data)
+  }
+
+  const loadState = () => {
+    memoryDb = loadJsonFile(ENDPOINTS_FILE, getDefaultData())
+    variables = loadJsonFile(VARIABLES_FILE, {})
+  }
+
+  loadState()
+
+  app.get('/api/data', (req, res) => {
+    res.json(getData())
+  })
+
+  app.post('/api/data', (req, res) => {
+    const incomingData = req.body
+    if (!incomingData || !Array.isArray(incomingData.projects)) {
+      return res.status(400).json({ error: 'Invalid data format' })
+    }
+    saveData(incomingData)
+    res.json({ success: true })
+  })
+
+  app.get('/api/variables', (req, res) => {
+    res.json(getVariables())
+  })
+
+  app.post('/api/variables', (req, res) => {
+    const incomingData = req.body
+    if (!incomingData || typeof incomingData !== 'object') {
+      return res.status(400).json({ error: 'Invalid variables format' })
+    }
+    saveVariables(incomingData)
+    res.json({ success: true })
+  })
+
+  app.post('/api/proxy', async (req, res) => {
+    const { url, method, params, payload } = req.body
+
+    if (!url) return res.status(400).json({ error: 'Missing Target URL' })
+
+    try {
+      const targetUrl = new URL(url)
+      if (params) {
+        try {
+          const queryObj = JSON.parse(params)
+          Object.keys(queryObj).forEach((k) => targetUrl.searchParams.append(k, queryObj[k]))
+        } catch (e) {}
+      }
+
+      const fetchOpts = {
+        method: method || 'GET',
+        headers: {},
+      }
+
+      if (payload && ['POST', 'PUT', 'PATCH'].includes(method)) {
+        fetchOpts.body = payload
+        fetchOpts.headers['Content-Type'] = 'application/json'
+      }
+
+      const startMs = Date.now()
+      let responseText = ''
+      let status = 500
+
+      try {
+        const response = await fetch(targetUrl.href, fetchOpts)
+        status = response.status
+        responseText = await response.text()
+      } catch (fetchErr) {
+        return res.status(502).json({ error: fetchErr.message })
+      }
+
+      const elapsedMs = Date.now() - startMs
+      let jsonFormatted = null
+      try {
+        jsonFormatted = JSON.parse(responseText)
+      } catch (e) {}
+
+      res.json({
+        status,
+        time: elapsedMs,
+        body: jsonFormatted || responseText,
+      })
+    } catch (err) {
+      res.status(500).json({ error: err.message })
+    }
+  })
+
+  app.use('/mock', (req, res) => {
+    const data = getData()
+    const vars = getVariables()
+    const requestPath = req.path
+    const requestMethod = req.method
+
+    const parts = requestPath.split('/').filter((p) => p.trim() !== '')
+    if (parts.length < 2) {
+      return res.status(404).json({
+        error:
+          'Invalid URL structure. Expected /mock/[project-slug]/[entity-slug] or /mock/[project-slug]/[entity-slug]/[endpoint-path]',
+      })
+    }
+
+    const projSlug = parts[0]
+    const stringSegmentEntity = parts[1]
+    const remainingPath = parts.length >= 3 ? '/' + parts.slice(2).join('/') : '/'
+
+    const project = data.projects.find((p) => slugify(p.name) === projSlug)
+    if (!project) return res.status(404).json({ error: `Mock Project '${projSlug}' not found` })
+
+    let matchedEndpoint = null
+    for (const entity of project.entities || []) {
+      if (slugify(entity.name) !== stringSegmentEntity) continue
+
+      const ep = (entity.endpoints || []).find((e) => {
+        const cleanEpPath = e.path.startsWith('/') ? e.path : `/${e.path}`
+        return cleanEpPath === remainingPath && e.method === requestMethod
+      })
+
+      if (ep) {
+        matchedEndpoint = ep
+        break
+      }
+    }
+
+    if (!matchedEndpoint) {
+      return res.status(404).json({
+        error: 'Endpoint not found in this project/entity',
+        requestedPath: remainingPath,
+        requestMethod,
+      })
+    }
+
+    const processedEndpoint = {
+      ...matchedEndpoint,
+      path: replaceVariables(matchedEndpoint.path, vars),
+      expectedParams: replaceVariables(matchedEndpoint.expectedParams, vars),
+      expectedPayload: replaceVariables(matchedEndpoint.expectedPayload, vars),
+      responseBody: replaceVariables(matchedEndpoint.responseBody, vars),
+      headers: matchedEndpoint.headers
+        ? matchedEndpoint.headers.map((h) => ({
+            key: replaceVariables(h.key, vars),
+            value: replaceVariables(h.value, vars),
+          }))
+        : [],
+      authorization: matchedEndpoint.authorization
+        ? {
+            type: matchedEndpoint.authorization.type,
+            value: replaceVariables(matchedEndpoint.authorization.value, vars),
+          }
+        : { type: 'None', value: '' },
+    }
+
+    if (isPostPutPatch(requestMethod) && processedEndpoint.expectedPayload) {
+      try {
+        const expectedObj = JSON.parse(processedEndpoint.expectedPayload)
+        const incomingObj = req.body || {}
+        const missingKeys = []
+        Object.keys(expectedObj).forEach((key) => {
+          if (incomingObj[key] === undefined) missingKeys.push(key)
+        })
+        if (missingKeys.length > 0)
+          return res.status(400).json({ error: 'Validation failed', missing_expected_keys: missingKeys })
+      } catch (e) {}
+    }
+
+    if (isGetDelete(requestMethod) && processedEndpoint.expectedParams) {
+      try {
+        const expectedParams = JSON.parse(processedEndpoint.expectedParams)
+        const incomingParams = req.query || {}
+        const missingParams = []
+        Object.keys(expectedParams).forEach((key) => {
+          if (incomingParams[key] === undefined) missingParams.push(key)
+        })
+        if (missingParams.length > 0)
+          return res.status(400).json({ error: 'Validation failed', missing_query_parameters: missingParams })
+      } catch (e) {}
+    }
+
+    let responseJson = {}
+    let isJson = true
+    try {
+      responseJson = processedEndpoint.responseBody ? JSON.parse(processedEndpoint.responseBody) : {}
+    } catch (e) {
+      responseJson = processedEndpoint.responseBody
+      isJson = false
+    }
+
+    const statusCode = parseInt(processedEndpoint.statusCode, 10) || 200
+    const delay = parseInt(processedEndpoint.delay, 10) || 0
+
+    setTimeout(() => {
+      if (processedEndpoint.headers && Array.isArray(processedEndpoint.headers)) {
+        processedEndpoint.headers.forEach((h) => {
+          if (h.key && h.value) {
+            res.setHeader(h.key, h.value)
+          }
+        })
+      }
+
+      if (processedEndpoint.authorization && processedEndpoint.authorization.type !== 'None') {
+        console.log(
+          `Authorization: ${processedEndpoint.authorization.type} - ${processedEndpoint.authorization.value}`,
+        )
+      }
+
+      res.status(statusCode)
+      if (isJson) {
+        res.setHeader('Content-Type', 'application/json')
+        res.send(JSON.stringify(responseJson, null, 2))
+      } else {
+        res.setHeader('Content-Type', 'text/plain')
+        res.send(responseJson)
+      }
+    }, delay)
+  })
+
+  app.use((req, res) => {
+    res.sendFile(path.join(PUBLIC_DIR, 'index.html'))
+  })
+
+  return {
+    app,
+    getData,
+    saveData,
+    getVariables,
+    saveVariables,
+  }
+}
+
+const startBemirrorServer = (options = {}) => {
+  const { app } = createBemirrorApp(options)
+  const port = options.port || process.env.PORT || 8000
+  const server = app.listen(port, () => {
+    console.log(`bemirror Micro Server is running on http://localhost:${port}`)
+  })
+
+  return {
+    app,
+    server,
+    close: () => server.close(),
+    port,
+  }
+}
+
+if (require.main === module) {
+  startBemirrorServer()
+}
+
+module.exports = {
+  createBemirrorApp,
+  startBemirrorServer,
+}