@platformatic/basic 2.0.0-alpha.3 → 2.0.0-alpha.5

package/NOTICE

@@ -0,0 +1,13 @@
+ Copyright 2024 Platformatic
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.

package/README.md

@@ -0,0 +1,13 @@
+# @platformatic/basic
+
+Check out the full documentation for Platformatic on [our website](https://docs.platformatic.dev).
+
+## Install
+
+```sh
+npm install @platformatic/basic
+```
+
+## License
+
+Apache 2.0

package/config.d.ts

@@ -0,0 +1,11 @@
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run json-schema-to-typescript to regenerate this file.
+ */
+
+export interface PlatformaticStackable {
+  $schema?: string;
+  [k: string]: unknown;
+}

package/eslint.config.js

@@ -1,3 +1,5 @@
 import neostandard from 'neostandard'
 
-export default neostandard({})
+export default neostandard({
+  ignores: ['test/tmp/version.js', '**/.next'],
+})

package/index.js

@@ -1,105 +1,91 @@
-'use strict'
-
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-
-import { ConfigManager } from '@platformatic/config'
-
+import { createRequire } from 'node:module'
+import { relative, resolve } from 'node:path'
+import { workerData } from 'node:worker_threads'
 import { packageJson, schema } from './lib/schema.js'
-import { ServerStackable } from './lib/server.js'
-
-const validFields = [
-  'main',
-  'exports',
-  'exports',
-  'exports#node',
-  'exports#import',
-  'exports#require',
-  'exports#default',
-  'exports#.#node',
-  'exports#.#import',
-  'exports#.#require',
-  'exports#.#default',
-]
-
-const validFilesBasenames = ['index', 'main', 'app', 'application', 'server', 'start', 'bundle', 'run', 'entrypoint']
-
-async function parsePackageJson (root) {
-  let entrypoint
-  let packageJson
-  let hadEntrypointField = false
+import { importFile } from './lib/utils.js'
 
+async function importStackablePackage (opts, pkg, autodetectDescription) {
   try {
-    packageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
-  } catch {
-    // No package.json, we only load the index.js file
-    packageJson = {}
-  }
+    try {
+      // Try regular import
+      return await import(pkg)
+    } catch (e) {
+      // Scope to the service
+      const require = createRequire(resolve(opts.context.directory, 'index.js'))
+      const imported = require.resolve(pkg)
+      return await importFile(imported)
+    }
+  } catch (e) {
+    const rootFolder = relative(process.cwd(), workerData.dirname)
 
-  for (const field of validFields) {
-    let current = packageJson
-    const sequence = field.split('#')
+    let errorMessage = `Unable to import package, "${pkg}". Please add it as a dependency `
 
-    while (current && sequence.length && typeof current !== 'string') {
-      current = current[sequence.shift()]
+    if (rootFolder) {
+      errorMessage += `in the package.json file in the folder ${rootFolder}.`
+    } else {
+      errorMessage += 'in the root package.json file.'
     }
 
-    if (typeof current === 'string') {
-      entrypoint = current
-      hadEntrypointField = true
-      break
+    if (!opts.config) {
+      const serviceRoot = relative(process.cwd(), opts.context.directory)
+      errorMessage += [
+        '', // Do not remove this
+        `Platformatic has auto-detected that service ${opts.context.serviceId} ${autodetectDescription}.`,
+        `We suggest you create a platformatic.application.json file in the folder ${serviceRoot} with the "$schema" property set to "https://schemas.platformatic.dev/${pkg}/${packageJson.version}.json".`,
+      ].join('\n')
     }
-  }
 
-  if (!entrypoint) {
-    for (const basename of validFilesBasenames) {
-      for (const ext of ['js', 'mjs', 'cjs']) {
-        const file = `${basename}.${ext}`
-
-        if (existsSync(resolve(root, file))) {
-          entrypoint = file
-          break
-        }
-      }
-
-      if (entrypoint) {
-        break
-      }
-    }
+    throw new Error(errorMessage)
   }
-
-  return { packageJson, entrypoint, hadEntrypointField }
 }
 
-function transformConfig () {
-  if (this.current.watch === undefined) {
-    this.current.watch = { enabled: false }
-  }
+async function buildStackable (opts) {
+  const root = opts.context.directory
+  let toImport = '@platformatic/node'
+  let autodetectDescription = 'is using a generic Node.js application'
 
-  if (typeof this.current.watch !== 'object') {
-    this.current.watch = { enabled: this.current.watch || false }
+  let rootPackageJson
+  try {
+    rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
+  } catch {
+    rootPackageJson = {}
   }
-}
 
-export async function buildStackable (opts) {
-  const root = opts.context.directory
-  const { entrypoint, hadEntrypointField } = await parsePackageJson(root)
+  if (!opts.config) {
+    const candidate = resolve(root, 'platformatic.application.json')
+
+    if (existsSync(candidate)) {
+      opts.config = candidate
+    }
+  }
 
-  const configManager = new ConfigManager({ schema, source: opts.config ?? {} })
-  await configManager.parseAndValidate()
+  const { dependencies, devDependencies } = rootPackageJson
 
-  const stackable = new ServerStackable(opts, root, configManager, entrypoint, hadEntrypointField)
+  if (dependencies?.next || devDependencies?.next) {
+    autodetectDescription = 'is using Next.js'
+    toImport = '@platformatic/next'
+  } else if (dependencies?.vite || devDependencies?.vite) {
+    autodetectDescription = 'is using Vite'
+    toImport = '@platformatic/vite'
+  }
 
-  return stackable
+  const imported = await importStackablePackage(opts, toImport, autodetectDescription)
+  return imported.buildStackable(opts)
 }
 
 export default {
   configType: 'nodejs',
-  configManagerConfig: {
-    transformConfig,
-  },
+  configManagerConfig: {},
   buildStackable,
   schema,
   version: packageJson.version,
 }
+
+export * from './lib/base.js'
+export * as errors from './lib/errors.js'
+export { schema, schemaComponents } from './lib/schema.js'
+export * from './lib/utils.js'
+export * from './lib/worker/child-manager.js'
+export * from './lib/worker/server-listener.js'

package/lib/base.js

@@ -1,9 +1,9 @@
 import pino from 'pino'
-import { packageJson } from './schema.js'
 
 export class BaseStackable {
-  constructor (options, root, configManager) {
-    this.type = 'nodejs'
+  constructor (type, version, options, root, configManager) {
+    this.type = type
+    this.version = version
     this.id = options.context.serviceId
     this.root = root
     this.configManager = configManager
@@ -12,7 +12,9 @@ export class BaseStackable {
     this.getGraphqlSchema = null
 
     // Setup the logger
-    const pinoOptions = { level: this.serverConfig?.logger?.level ?? 'trace' }
+    const pinoOptions = {
+      level: (this.configManager.current.server ?? this.serverConfig)?.logger?.level ?? 'trace',
+    }
 
     if (this.id) {
       pinoOptions.name = this.id
@@ -21,8 +23,8 @@ export class BaseStackable {
 
     // Setup globals
     globalThis.platformatic = {
-      setOpenAPISchema: this.setOpenAPISchema.bind(this),
-      setGraphQLSchema: this.setGraphQLSchema.bind(this),
+      setOpenapiSchema: this.setOpenapiSchema.bind(this),
+      setGraphqlSchema: this.setGraphqlSchema.bind(this),
     }
   }
 
@@ -48,7 +50,7 @@ export class BaseStackable {
   }
 
   async getInfo () {
-    return { type: this.type, version: packageJson.version }
+    return { type: this.type, version: this.version }
   }
 
   getDispatchFunc () {
@@ -67,11 +69,11 @@ export class BaseStackable {
     return this.graphqlSchema
   }
 
-  setOpenAPISchema (schema) {
+  setOpenapiSchema (schema) {
     this.openapiSchema = schema
   }
 
-  setGraphQLSchema (schema) {
+  setGraphqlSchema (schema) {
     this.graphqlSchema = schema
   }
 

package/lib/errors.js

@@ -0,0 +1,8 @@
+import createError from '@fastify/error'
+
+const ERROR_PREFIX = 'PLT_BASIC'
+
+export const UnsupportedVersion = createError(
+  `${ERROR_PREFIX}_UNSUPPORTED_VERSION`,
+  '%s version %s is not supported. Please use version %s.'
+)

package/lib/schema.js

@@ -1,8 +1,31 @@
 import { schemas } from '@platformatic/utils'
 import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
 
-export const packageJson = JSON.parse(readFileSync(fileURLToPath(new URL('../package.json', import.meta.url))))
+export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
+
+const application = {
+  type: 'object',
+  properties: {
+    basePath: {
+      type: 'string',
+    },
+  },
+  additionalProperties: false,
+}
+
+const watch = {
+  anyOf: [
+    schemas.watch,
+    {
+      type: 'boolean',
+    },
+    {
+      type: 'string',
+    },
+  ],
+}
+
+export const schemaComponents = { application, watch }
 
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/basic/${packageJson.version}.json`,
@@ -13,18 +36,11 @@ export const schema = {
     $schema: {
       type: 'string',
     },
-    server: schemas.server,
-    watch: {
-      anyOf: [
-        schemas.watch,
-        {
-          type: 'boolean',
-        },
-        {
-          type: 'string',
-        },
-      ],
-    },
   },
-  additionalProperties: false,
+  additionalProperties: true,
+}
+
+/* c8 ignore next 3 */
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
 }

package/lib/utils.js

@@ -1,6 +1,4 @@
-'use strict'
-
-import { tracingChannel } from 'node:diagnostics_channel'
+import { pathToFileURL } from 'node:url'
 import { request } from 'undici'
 
 export function getServerUrl (server) {
@@ -9,42 +7,6 @@ export function getServerUrl (server) {
   return new URL(family === 'IPv6' ? `http://[${address}]:${port}` : `http://${address}:${port}`).origin
 }
 
-// Paolo: This is kinda hackish but there is no better way. I apologize.
-export function isFastify (app) {
-  return Object.getOwnPropertySymbols(app).some(s => s.description === 'fastify.state')
-}
-
-export function createPortManager () {
-  let resolve
-  let reject
-
-  const promise = new Promise((_resolve, _reject) => {
-    resolve = _resolve
-    reject = _reject
-  })
-
-  const subscribers = {
-    asyncStart ({ options }) {
-      options.port = 0
-    },
-    asyncEnd: ({ server }) => {
-      resolve(server)
-    },
-    error: reject,
-  }
-
-  tracingChannel('net.server.listen').subscribe(subscribers)
-
-  return {
-    getServer () {
-      return promise
-    },
-    destroy () {
-      tracingChannel('net.server.listen').unsubscribe(subscribers)
-    },
-  }
-}
-
 export async function injectViaRequest (baseUrl, injectParams, onInject) {
   const url = new URL(injectParams.url, baseUrl).href
   const requestParams = { method: injectParams.method, headers: injectParams.headers }
@@ -75,3 +37,8 @@ export async function injectViaRequest (baseUrl, injectParams, onInject) {
     throw error
   }
 }
+
+// This is to avoid common path/URL problems on Windows
+export function importFile (path) {
+  return import(pathToFileURL(path))
+}

package/lib/worker/child-manager.js

@@ -0,0 +1,90 @@
+import { ITC } from '@platformatic/itc'
+import { subscribe, unsubscribe } from 'node:diagnostics_channel'
+import { once } from 'node:events'
+import { workerData } from 'node:worker_threads'
+import { request } from 'undici'
+
+export const childProcessWorkerFile = new URL('./child-process.js', import.meta.url)
+
+export class ChildManager extends ITC {
+  #child
+  #listener
+  #injectedNodeOptions
+  #originalNodeOptions
+
+  constructor ({ loader, context }) {
+    super({})
+
+    const childHandler = ({ process: child }) => {
+      unsubscribe('child_process', childHandler)
+
+      this.#child = child
+      this.#child.once('exit', () => {
+        this.emit('exit')
+      })
+
+      this.listen()
+    }
+
+    subscribe('child_process', childHandler)
+
+    this.handle('log', message => {
+      workerData.loggingPort.postMessage(JSON.parse(message))
+    })
+
+    this.handle('fetch', this.#fetch.bind(this))
+
+    this.#prepareChildEnvironment(loader, context)
+  }
+
+  inject () {
+    process.env.NODE_OPTIONS = this.#injectedNodeOptions
+  }
+
+  eject () {
+    process.env.NODE_OPTIONS = this.#originalNodeOptions
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+    this.#child.on('message', this.#listener)
+  }
+
+  _send (request) {
+    this.#child.send(request)
+  }
+
+  _createClosePromise () {
+    return once(this.#child, 'exit')
+  }
+
+  _close () {
+    this.#child.removeListener('message', this.#listener)
+    this.#child.kill('SIGKILL')
+  }
+
+  #prepareChildEnvironment (loader, context) {
+    this.#originalNodeOptions = process.env.NODE_OPTIONS
+
+    const loaderScript = `
+      import { register } from 'node:module';
+      globalThis.platformatic=${JSON.stringify(context).replaceAll('"', '\\"')};    
+      register('${loader}',{ data: globalThis.platformatic });
+    `
+
+    this.#injectedNodeOptions = [
+      `--import="data:text/javascript,${loaderScript.replaceAll(/\n/g, '')}"`,
+      `--import=${childProcessWorkerFile}`,
+      process.env.NODE_OPTIONS ?? '',
+    ].join(' ')
+  }
+
+  async #fetch (opts) {
+    const { statusCode, headers, body } = await request(opts)
+
+    const rawPayload = Buffer.from(await body.arrayBuffer())
+    const payload = rawPayload.toString()
+
+    return { statusCode, headers, body: payload, payload, rawPayload }
+  }
+}

package/lib/worker/child-process.js

@@ -0,0 +1,150 @@
+import { ITC } from '@platformatic/itc'
+import { createPinoWritable, DestinationWritable, withResolvers } from '@platformatic/utils'
+import { tracingChannel } from 'node:diagnostics_channel'
+import pino from 'pino'
+import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
+
+function createInterceptor (itc) {
+  return function (dispatch) {
+    return async (opts, handler) => {
+      let url = opts.origin
+      if (!(url instanceof URL)) {
+        url = new URL(opts.path, url)
+      }
+
+      // Other URLs are handled normally
+      if (!url.hostname.endsWith('.plt.local')) {
+        return dispatch(opts, handler)
+      }
+
+      const headers = {
+        ...opts?.headers,
+      }
+
+      delete headers.connection
+      delete headers['transfer-encoding']
+      headers.host = url.host
+
+      const requestOpts = {
+        ...opts,
+        headers,
+      }
+      delete requestOpts.dispatcher
+
+      itc
+        .send('fetch', requestOpts)
+        .then(res => {
+          if (res.rawPayload && !Buffer.isBuffer(res.rawPayload)) {
+            res.rawPayload = Buffer.from(res.rawPayload.data)
+          }
+
+          const headers = []
+          for (const [key, value] of Object.entries(res.headers)) {
+            if (Array.isArray(value)) {
+              for (const v of value) {
+                headers.push(key)
+                headers.push(v)
+              }
+            } else {
+              headers.push(key)
+              headers.push(value)
+            }
+          }
+
+          handler.onHeaders(res.statusCode, headers, () => {}, res.statusMessage)
+          handler.onData(res.rawPayload)
+          handler.onComplete([])
+        })
+        .catch(e => {
+          handler.onError(new Error(e.message))
+        })
+
+      return true
+    }
+  }
+}
+
+class ChildProcessWritable extends DestinationWritable {
+  #itc
+
+  constructor (options) {
+    const { itc, ...opts } = options
+
+    super(opts)
+    this.#itc = itc
+  }
+
+  _send (message) {
+    this.#itc.send('log', JSON.stringify(message))
+  }
+}
+
+class ChildProcess extends ITC {
+  #listener
+  #child
+  #logger
+
+  constructor () {
+    super({})
+
+    this.listen()
+    this.#setupLogger()
+    this.#setupServer()
+    this.#setupInterceptors()
+  }
+
+  _setupListener (listener) {
+    this.#listener = listener
+    process.on('message', this.#listener)
+  }
+
+  _send (request) {
+    process.send(request)
+  }
+
+  _createClosePromise () {
+    const { promise } = withResolvers()
+    return promise
+  }
+
+  _close () {
+    process.kill(process.pid, 'SIGKILL')
+    this.#child.removeListener('message', this.#listener)
+  }
+
+  #setupLogger () {
+    const destination = new ChildProcessWritable({ itc: this })
+    this.#logger = pino({ level: 'info', ...globalThis.platformatic.logger }, destination)
+
+    Reflect.defineProperty(process, 'stdout', { value: createPinoWritable(this.#logger, 'info') })
+    Reflect.defineProperty(process, 'stderr', { value: createPinoWritable(this.#logger, 'error') })
+  }
+
+  #setupServer () {
+    const subscribers = {
+      asyncStart ({ options }) {
+        options.port = 0
+      },
+      asyncEnd: ({ server }) => {
+        tracingChannel('net.server.listen').unsubscribe(subscribers)
+
+        const { family, address, port } = server.address()
+        const url = new URL(family === 'IPv6' ? `http://[${address}]:${port}` : `http://${address}:${port}`).origin
+
+        this.notify('url', url)
+      },
+      error: error => {
+        tracingChannel('net.server.listen').unsubscribe(subscribers)
+        this.notify('error', error)
+      },
+    }
+
+    tracingChannel('net.server.listen').subscribe(subscribers)
+  }
+
+  #setupInterceptors () {
+    setGlobalDispatcher(getGlobalDispatcher().compose(createInterceptor(this)))
+  }
+}
+
+globalThis[Symbol.for('plt.children.itc')] = new ChildProcess()

package/lib/worker/server-listener.js

@@ -0,0 +1,29 @@
+import { withResolvers } from '@platformatic/utils'
+import { tracingChannel } from 'node:diagnostics_channel'
+
+export function createServerListener () {
+  const { promise, resolve, reject } = withResolvers()
+
+  const subscribers = {
+    asyncStart ({ options }) {
+      options.port = 0
+    },
+    asyncEnd ({ server }) {
+      resolve(server)
+    },
+    error (error) {
+      cancel()
+      reject(error)
+    },
+  }
+
+  function cancel () {
+    tracingChannel('net.server.listen').unsubscribe(subscribers)
+  }
+
+  tracingChannel('net.server.listen').subscribe(subscribers)
+  promise.finally(cancel)
+  promise.cancel = resolve.bind(null, null)
+
+  return promise
+}