@platformatic/basic 2.0.0-alpha.4 → 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

@@ -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,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 { NextStackable } from './lib/next.js'
+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'
-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
+    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,
-    packageJson: { dependencies, devDependencies },
-  } = 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
 
-  let stackable
   if (dependencies?.next || devDependencies?.next) {
-    stackable = new NextStackable(opts, root, configManager)
+    autodetectDescription = 'is using Next.js'
+    toImport = '@platformatic/next'
   } 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'
   }
 
-  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
@@ -50,7 +50,7 @@ export class BaseStackable {
   }
 
   async getInfo () {
-    return { type: this.type, version: packageJson.version }
+    return { type: this.type, version: this.version }
   }
 
   getDispatchFunc () {

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)
 
@@ -31,6 +32,8 @@ export class ChildManager extends ITC {
       workerData.loggingPort.postMessage(JSON.parse(message))
     })
 
+    this.handle('fetch', this.#fetch.bind(this))
+
     this.#prepareChildEnvironment(loader, context)
   }
 
@@ -75,4 +78,13 @@ export class ChildManager extends ITC {
       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()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "2.0.0-alpha.4",
+  "version": "2.0.0-alpha.5",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -15,17 +15,13 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "dependencies": {
-    "@babel/generator": "^7.25.0",
-    "@babel/parser": "^7.25.3",
-    "@babel/traverse": "^7.25.3",
-    "@babel/types": "^7.25.2",
     "@fastify/error": "^4.0.0",
-    "light-my-request": "^5.13.0",
     "pino": "^9.3.2",
     "semver": "^7.6.3",
     "undici": "^6.19.5",
-    "@platformatic/config": "2.0.0-alpha.4",
-    "@platformatic/itc": "2.0.0-alpha.4"
+    "@platformatic/config": "2.0.0-alpha.5",
+    "@platformatic/utils": "2.0.0-alpha.5",
+    "@platformatic/itc": "2.0.0-alpha.5"
   },
   "devDependencies": {
     "borp": "^0.17.0",
@@ -40,13 +36,10 @@
     "typescript": "^5.5.4",
     "vite": "^5.4.0",
     "ws": "^8.18.0",
-    "@platformatic/composer": "2.0.0-alpha.4",
-    "@platformatic/utils": "2.0.0-alpha.4",
-    "@platformatic/service": "2.0.0-alpha.4"
+    "@platformatic/composer": "2.0.0-alpha.5",
+    "@platformatic/service": "2.0.0-alpha.5"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --timeout=180000",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout=180000",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
     "build": "pnpm run gen-schema && pnpm run gen-types",