@platformatic/basic 2.0.0-alpha.4 → 2.0.0-alpha.6

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

@@ -7,153 +7,5 @@
 
 export interface PlatformaticStackable {
   $schema?: string;
-  server?: {
-    hostname?: string;
-    port?: number | string;
-    pluginTimeout?: number;
-    healthCheck?:
-      | boolean
-      | {
-          enabled?: boolean;
-          interval?: number;
-          [k: string]: unknown;
-        };
-    ignoreTrailingSlash?: boolean;
-    ignoreDuplicateSlashes?: boolean;
-    connectionTimeout?: number;
-    keepAliveTimeout?: number;
-    maxRequestsPerSocket?: number;
-    forceCloseConnections?: boolean | string;
-    requestTimeout?: number;
-    bodyLimit?: number;
-    maxParamLength?: number;
-    disableRequestLogging?: boolean;
-    exposeHeadRoutes?: boolean;
-    logger?:
-      | boolean
-      | {
-          level?: string;
-          transport?:
-            | {
-                target?: string;
-                options?: {
-                  [k: string]: unknown;
-                };
-              }
-            | {
-                targets?: {
-                  target?: string;
-                  options?: {
-                    [k: string]: unknown;
-                  };
-                  level?: string;
-                  additionalProperties?: never;
-                  [k: string]: unknown;
-                }[];
-                options?: {
-                  [k: string]: unknown;
-                };
-              };
-          pipeline?: {
-            target?: string;
-            options?: {
-              [k: string]: unknown;
-            };
-          };
-          [k: string]: unknown;
-        };
-    serializerOpts?: {
-      schema?: {
-        [k: string]: unknown;
-      };
-      ajv?: {
-        [k: string]: unknown;
-      };
-      rounding?: "floor" | "ceil" | "round" | "trunc";
-      debugMode?: boolean;
-      mode?: "debug" | "standalone";
-      largeArraySize?: number | string;
-      largeArrayMechanism?: "default" | "json-stringify";
-      [k: string]: unknown;
-    };
-    caseSensitive?: boolean;
-    requestIdHeader?: string | false;
-    requestIdLogLabel?: string;
-    jsonShorthand?: boolean;
-    trustProxy?: boolean | string | string[] | number;
-    http2?: boolean;
-    https?: {
-      allowHTTP1?: boolean;
-      key:
-        | string
-        | {
-            path?: string;
-          }
-        | (
-            | string
-            | {
-                path?: string;
-              }
-          )[];
-      cert:
-        | string
-        | {
-            path?: string;
-          }
-        | (
-            | string
-            | {
-                path?: string;
-              }
-          )[];
-      requestCert?: boolean;
-      rejectUnauthorized?: boolean;
-    };
-    cors?: {
-      origin?:
-        | boolean
-        | string
-        | (
-            | string
-            | {
-                regexp: string;
-                [k: string]: unknown;
-              }
-          )[]
-        | {
-            regexp: string;
-            [k: string]: unknown;
-          };
-      methods?: string[];
-      /**
-       * Comma separated string of allowed headers.
-       */
-      allowedHeaders?: string;
-      exposedHeaders?: string[] | string;
-      credentials?: boolean;
-      maxAge?: number;
-      preflightContinue?: boolean;
-      optionsSuccessStatus?: number;
-      preflight?: boolean;
-      strictPreflight?: boolean;
-      hideOptionsRoute?: boolean;
-    };
-  };
-  watch?:
-    | {
-        enabled?: boolean | string;
-        /**
-         * @minItems 1
-         */
-        allow?: [string, ...string[]];
-        ignore?: string[];
-      }
-    | boolean
-    | string;
-  application?: {
-    base?: string;
-  };
-  vite?: {
-    configFile?: string | boolean;
-  };
+  [k: string]: unknown;
 }

package/index.js

@@ -1,118 +1,108 @@
-'use strict'
-
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
-import { resolve } from 'node:path'
-
-import { ConfigManager } from '@platformatic/config'
-
-import { NextStackable } from './lib/next.js'
+import { createRequire } from 'node:module'
+import { relative, resolve } from 'node:path'
+import { workerData } from 'node:worker_threads'
+import pino from 'pino'
 import { packageJson, schema } from './lib/schema.js'
-import { ServerStackable } from './lib/server.js'
-import { ViteStackable } from './lib/vite.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
-    }
+    throw new Error(errorMessage)
   }
+}
 
-  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
-        }
-      }
+async function buildStackable (opts) {
+  const root = opts.context.directory
+  let toImport = '@platformatic/node'
+  let autodetectDescription = 'is using a generic Node.js application'
 
-      if (entrypoint) {
-        break
-      }
-    }
+  let rootPackageJson
+  try {
+    rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
+  } catch {
+    rootPackageJson = {}
   }
 
-  return { packageJson, entrypoint, hadEntrypointField }
-}
+  const hadConfig = opts.config
 
-function transformConfig () {
-  if (this.current.watch === undefined) {
-    this.current.watch = { enabled: false }
-  }
+  if (!hadConfig) {
+    const candidate = resolve(root, 'platformatic.application.json')
 
-  if (typeof this.current.watch !== 'object') {
-    this.current.watch = { enabled: this.current.watch || false }
+    if (existsSync(candidate)) {
+      opts.config = candidate
+    }
   }
-}
 
-export async function buildStackable (opts) {
-  const root = opts.context.directory
-  const {
-    entrypoint,
-    hadEntrypointField,
-    packageJson: { dependencies, devDependencies },
-  } = await parsePackageJson(root)
-
-  const configManager = new ConfigManager({ schema, source: opts.config ?? {} })
-  await configManager.parseAndValidate()
+  const { dependencies, devDependencies } = rootPackageJson
 
-  let stackable
   if (dependencies?.next || devDependencies?.next) {
-    stackable = new NextStackable(opts, root, configManager)
+    autodetectDescription = 'is using Next.js'
+    toImport = '@platformatic/next'
+  } else if (dependencies?.['@remix-run/dev'] || devDependencies?.['@remix-run/dev']) {
+    autodetectDescription = 'is using Remix'
+    toImport = '@platformatic/remix'
   } else if (dependencies?.vite || devDependencies?.vite) {
-    stackable = new ViteStackable(opts, root, configManager)
-  } else {
-    stackable = new ServerStackable(opts, root, configManager, entrypoint, hadEntrypointField)
+    autodetectDescription = 'is using Vite'
+    toImport = '@platformatic/vite'
+  } else if (dependencies?.astro || devDependencies?.astro) {
+    autodetectDescription = 'is using Astro'
+    toImport = '@platformatic/astro'
   }
 
-  return stackable
+  const imported = await importStackablePackage(opts, toImport, autodetectDescription)
+
+  if (!hadConfig) {
+    const serviceRoot = relative(process.cwd(), opts.context.directory)
+    const logger = pino({
+      level: opts.context.serverConfig?.logger?.level ?? 'warn',
+      name: opts.context.serviceId
+    })
+
+    logger.warn(
+      [
+        `Platformatic has auto-detected that service ${opts.context.serviceId} ${autodetectDescription}.\n`,
+        `We suggest you create a platformatic.application.json file in the folder ${serviceRoot} with the "$schema" `,
+        `property set to "https://schemas.platformatic.dev/${toImport}/${packageJson.version}.json".`
+      ].join('')
+    )
+  }
+
+  return imported.buildStackable(opts)
 }
 
 export default {
   configType: 'nodejs',
-  configManagerConfig: {
-    transformConfig,
-  },
+  configManagerConfig: {},
   buildStackable,
   schema,
-  version: packageJson.version,
+  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
@@ -13,7 +13,7 @@ export class BaseStackable {
 
     // Setup the logger
     const pinoOptions = {
-      level: (this.configManager.current.server ?? this.serverConfig)?.logger?.level ?? 'trace',
+      level: (this.configManager.current.server ?? this.serverConfig)?.logger?.level ?? 'trace'
     }
 
     if (this.id) {
@@ -22,10 +22,10 @@ export class BaseStackable {
     this.logger = pino(pinoOptions)
 
     // Setup globals
-    globalThis.platformatic = {
+    this.registerGlobals({
       setOpenapiSchema: this.setOpenapiSchema.bind(this),
-      setGraphqlSchema: this.setGraphqlSchema.bind(this),
-    }
+      setGraphqlSchema: this.setGraphqlSchema.bind(this)
+    })
   }
 
   getUrl () {
@@ -45,12 +45,12 @@ export class BaseStackable {
       enabled,
       path: this.root,
       allow: config.watch?.allow,
-      ignore: config.watch?.ignore,
+      ignore: config.watch?.ignore
     }
   }
 
   async getInfo () {
-    return { type: this.type, version: packageJson.version }
+    return { type: this.type, version: this.version }
   }
 
   getDispatchFunc () {
@@ -81,4 +81,8 @@ export class BaseStackable {
     const logLevel = level ?? 'info'
     this.logger[logLevel](message)
   }
+
+  registerGlobals (globals) {
+    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
+  }
 }

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,38 +36,8 @@ export const schema = {
     $schema: {
       type: 'string',
     },
-    server: schemas.server,
-    watch: {
-      anyOf: [
-        schemas.watch,
-        {
-          type: 'boolean',
-        },
-        {
-          type: 'string',
-        },
-      ],
-    },
-    application: {
-      type: 'object',
-      properties: {
-        base: {
-          type: 'string',
-        },
-      },
-      additionalProperties: false,
-    },
-    vite: {
-      type: 'object',
-      properties: {
-        configFile: {
-          oneOf: [{ type: 'string' }, { type: 'boolean' }],
-        },
-      },
-      additionalProperties: false,
-    },
   },
-  additionalProperties: false,
+  additionalProperties: true,
 }
 
 /* c8 ignore next 3 */

package/lib/utils.js

@@ -7,11 +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 async function injectViaRequest (baseUrl, injectParams, onInject) {
   const url = new URL(injectParams.url, baseUrl).href
   const requestParams = { method: injectParams.method, headers: injectParams.headers }
@@ -43,6 +38,7 @@ export async function injectViaRequest (baseUrl, injectParams, onInject) {
   }
 }
 
+// This is to avoid common path/URL problems on Windows
 export function importFile (path) {
   return import(pathToFileURL(path))
 }

package/lib/worker/child-manager.js

@@ -2,6 +2,7 @@ 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)
 
@@ -12,7 +13,16 @@ export class ChildManager extends ITC {
   #originalNodeOptions
 
   constructor ({ loader, context }) {
-    super({})
+    super({
+      handlers: {
+        log (message) {
+          workerData.loggingPort.postMessage(JSON.parse(message))
+        },
+        fetch: request => {
+          return this.#fetch(request)
+        }
+      }
+    })
 
     const childHandler = ({ process: child }) => {
       unsubscribe('child_process', childHandler)
@@ -27,10 +37,6 @@ export class ChildManager extends ITC {
 
     subscribe('child_process', childHandler)
 
-    this.handle('log', message => {
-      workerData.loggingPort.postMessage(JSON.parse(message))
-    })
-
     this.#prepareChildEnvironment(loader, context)
   }
 
@@ -72,7 +78,16 @@ export class ChildManager extends ITC {
     this.#injectedNodeOptions = [
       `--import="data:text/javascript,${loaderScript.replaceAll(/\n/g, '')}"`,
       `--import=${childProcessWorkerFile}`,
-      process.env.NODE_OPTIONS ?? '',
+      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

@@ -2,6 +2,67 @@ 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
@@ -29,6 +90,7 @@ class ChildProcess extends ITC {
     this.listen()
     this.#setupLogger()
     this.#setupServer()
+    this.#setupInterceptors()
   }
 
   _setupListener (listener) {
@@ -79,6 +141,10 @@ class ChildProcess extends ITC {
 
     tracingChannel('net.server.listen').subscribe(subscribers)
   }
+
+  #setupInterceptors () {
+    setGlobalDispatcher(getGlobalDispatcher().compose(createInterceptor(this)))
+  }
 }
 
 globalThis[Symbol.for('plt.children.itc')] = new ChildProcess()