@platformatic/react-router 0.0.1 → 3.28.2

package/lib/capability.js

@@ -0,0 +1,203 @@
+import {
+  cleanBasePath,
+  createServerListener,
+  ensureTrailingSlash,
+  errors,
+  getServerUrl,
+  importFile,
+  resolvePackageViaCJS
+} from '@platformatic/basic'
+import { ViteCapability } from '@platformatic/vite'
+import { createRequestHandler } from '@react-router/express'
+import express from 'express'
+import inject from 'light-my-request'
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { pinoHttp } from 'pino-http'
+import { satisfies } from 'semver'
+import { packageJson } from './schema.js'
+
+const supportedVersions = '^7.0.0'
+
+export class ReactRouterCapability extends ViteCapability {
+  #app
+  #server
+  #reactRouter
+  #basePath
+
+  constructor (root, config, context) {
+    super(root, config, context)
+    this.type = 'react-router'
+    this.version = packageJson.version
+  }
+
+  async init () {
+    await super.init()
+
+    if (!this.isProduction) {
+      this.#reactRouter = resolve(dirname(await resolvePackageViaCJS(this.root, 'react-router')), '../..')
+      const reactRouterPackage = JSON.parse(await readFile(resolve(this.#reactRouter, 'package.json'), 'utf-8'))
+
+      if (!satisfies(reactRouterPackage.version, supportedVersions)) {
+        throw new errors.UnsupportedVersion('react-router', reactRouterPackage.version, supportedVersions)
+      }
+    }
+
+    const config = this.config
+    this.#basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    this.registerGlobals({ basePath: this.#basePath })
+
+    this.subprocessTerminationSignal = 'SIGKILL'
+  }
+
+  async start ({ listen }) {
+    const config = this.config
+    const reactRouterConfig = await this.#getReactRouterConfig()
+
+    if (this.isProduction) {
+      const command = this.config.application.commands.production
+
+      this.outputDirectory = resolve(this.root, config.reactRouter.outputDirectory, 'client')
+      this.buildInfoPath = resolve(this.root, config.reactRouter.outputDirectory, '.platformatic-build.json')
+
+      if (command) {
+        return this.startWithCommand(command)
+      }
+
+      if (reactRouterConfig.ssr) {
+        return this.#startSSRProduction(listen)
+      }
+    }
+
+    return super.start({ listen })
+  }
+
+  async stop () {
+    const reactRouterConfig = await this.#getReactRouterConfig()
+
+    if (reactRouterConfig.ssr) {
+      await this._stop()
+
+      if (this.#server?.listening) {
+        await this._closeServer(this.#server)
+      }
+
+      return
+    }
+
+    return super.stop()
+  }
+
+  async build () {
+    const config = this.config
+    const command = config.application.commands.build
+    const basePath = config.application?.basePath
+      ? ensureTrailingSlash(cleanBasePath(config.application?.basePath))
+      : undefined
+
+    const reactRouterConfig = await this.#getReactRouterConfig()
+
+    if (command) {
+      return this.buildWithCommand(command, basePath)
+    }
+
+    await this.buildWithCommand(`react-router build -m production ${this.root}`, basePath)
+
+    await writeFile(
+      resolve(this.root, config.reactRouter.outputDirectory, '.platformatic-build.json'),
+      JSON.stringify({ basePath: reactRouterConfig.basename ?? '/' }),
+      'utf-8'
+    )
+  }
+
+  async getMeta () {
+    const reactRouterConfig = await this.#getReactRouterConfig()
+    return super.getMeta(reactRouterConfig.basename)
+  }
+
+  async inject (injectParams, onInject) {
+    const reactRouterConfig = await this.#getReactRouterConfig()
+
+    if (this.isProduction && reactRouterConfig.ssr) {
+      return this.#inject(injectParams, onInject)
+    }
+
+    return super.inject(injectParams, onInject)
+  }
+
+  async #getReactRouterConfig () {
+    const ext = ['ts', 'js'].find(ext => existsSync(resolve(this.root, `react-router.config.${ext}`)))
+
+    if (!ext) {
+      return {}
+    }
+
+    const { default: reactRouterConfig } = await importFile(resolve(this.root, `react-router.config.${ext}`))
+    return reactRouterConfig ?? {}
+  }
+
+  async #startSSRProduction (listen) {
+    // Listen if entrypoint
+    if (this.#app && listen) {
+      const serverOptions = this.serverConfig
+      const listenOptions = { host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 }
+
+      if (typeof serverOptions?.backlog === 'number') {
+        createServerListener(false, false, { backlog: serverOptions.backlog })
+      }
+
+      this.#server = await new Promise((resolve, reject) => {
+        return this.#app
+          .listen(listenOptions, function () {
+            resolve(this)
+          })
+          .on('error', reject)
+      })
+
+      this.url = getServerUrl(this.#server)
+
+      return this.url
+    }
+
+    const config = this.config
+
+    const clientRoot = resolve(this.root, config.reactRouter.outputDirectory, 'client')
+    const serverRoot = resolve(this.root, config.reactRouter.outputDirectory, 'server')
+    this.verifyOutputDirectory(clientRoot)
+    this.verifyOutputDirectory(serverRoot)
+    this.#basePath = await this._getBasePathFromBuildInfo()
+
+    const { entrypoint } = await importFile(resolve(serverRoot, 'index.js'))
+
+    // Setup express app
+    this.#app = express()
+    this._setApp(this.#app)
+    this.#app.disable('x-powered-by')
+    this.#app.use(pinoHttp({ logger: this.logger }))
+    this.#app.use(this.#basePath, express.static(clientRoot))
+    this.#app.all(
+      `${ensureTrailingSlash(cleanBasePath(this.#basePath))}*`,
+      createRequestHandler({ build: () => entrypoint })
+    )
+
+    await this._collectMetrics()
+    return this.url
+  }
+
+  async #inject (injectParams, onInject) {
+    const res = await inject(this.#app, injectParams, onInject)
+
+    /* c8 ignore next 3 */
+    if (onInject) {
+      return
+    }
+
+    // Since inject might be called from the main thread directly via ITC, let's clean it up
+    const { statusCode, headers, body, payload, rawPayload } = res
+    return { statusCode, headers, body, payload, rawPayload }
+  }
+}

package/lib/schema.js

@@ -0,0 +1,47 @@
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/foundation'
+import { schemaComponents as viteSchemaComponents } from '@platformatic/vite'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
+
+export const reactRouter = {
+  type: 'object',
+  properties: {
+    outputDirectory: {
+      type: 'string',
+      default: 'build'
+    }
+  },
+  default: {},
+  additionalProperties: false
+}
+
+export const schemaComponents = { reactRouter }
+
+export const schema = {
+  $id: `https://schemas.platformatic.dev/@platformatic/react-router/${packageJson.version}.json`,
+  $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'Platformatic React Router Config',
+  type: 'object',
+  properties: {
+    $schema: {
+      type: 'string'
+    },
+    logger: utilsSchemaComponents.logger,
+    server: utilsSchemaComponents.server,
+    watch: basicSchemaComponents.watch,
+    application: basicSchemaComponents.buildableApplication,
+    runtime: utilsSchemaComponents.wrappedRuntime,
+    vite: viteSchemaComponents.vite,
+    reactRouter
+  },
+  additionalProperties: false
+}
+
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
+}

package/package.json

@@ -1,12 +1,58 @@
 {
   "name": "@platformatic/react-router",
-  "version": "0.0.1",
-  "description": "",
-  "license": "MIT",
-  "author": "Matteo Collina <hello@matteocollina.com>",
-  "type": "commonjs",
+  "version": "3.28.2",
+  "description": "Platformatic React Router Capability",
   "main": "index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/platformatic/platformatic.git"
+  },
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/platformatic/platformatic/issues"
+  },
+  "homepage": "https://github.com/platformatic/platformatic#readme",
+  "dependencies": {
+    "express": "^4.19.2",
+    "light-my-request": "^6.0.0",
+    "pino-http": "^10.2.0",
+    "semver": "^7.6.3",
+    "@platformatic/basic": "3.28.2",
+    "@platformatic/vite": "3.28.2",
+    "@platformatic/foundation": "3.28.2"
+  },
+  "devDependencies": {
+    "@react-router/dev": "^7.10.0",
+    "@react-router/express": "^7.10.1",
+    "@react-router/node": "^7.10.0",
+    "@types/react": "^19.1.11",
+    "@types/react-dom": "^19.1.7",
+    "cleaner-spec-reporter": "^0.5.0",
+    "eslint": "9",
+    "fastify": "^5.0.0",
+    "isbot": "^5.1.17",
+    "json-schema-to-typescript": "^15.0.1",
+    "neostandard": "^0.12.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
+    "react-router": "^7.10.0",
+    "react-router-dom": "^7.10.0",
+    "typescript": "^5.5.4",
+    "vite": "^7.1.7",
+    "ws": "^8.18.0",
+    "@platformatic/gateway": "3.28.2",
+    "@platformatic/service": "3.28.2"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "gen-schema": "node lib/schema.js > schema.json",
+    "gen-types": "json2ts > config.d.ts < schema.json",
+    "build": "npm run gen-schema && npm run gen-types",
+    "lint": "eslint"
   }
-}
+}