@platformatic/runtime 3.4.1 → 3.5.0

package/lib/scheduler.js

@@ -0,0 +1,119 @@
+import { CronJob, validateCronExpression } from 'cron'
+import { setTimeout } from 'node:timers/promises'
+import { request } from 'undici'
+
+export class SchedulerService {
+  constructor (schedulerConfig, dispatcher, logger) {
+    this.logger = logger
+    this.jobsConfig = []
+    this.cronJobs = []
+    this.dispatcher = dispatcher
+    this.validateCronSchedulers(schedulerConfig)
+  }
+
+  validateCronSchedulers (schedulerConfig) {
+    for (const config of schedulerConfig) {
+      // Skip disabled schedulers
+      if (config.enabled === false) {
+        continue
+      }
+
+      // Validate cron expression
+      const validation = validateCronExpression(config.cron)
+      if (!validation.valid) {
+        throw new Error(`Invalid cron expression "${config.cron}" for scheduler "${config.name}"`)
+      }
+
+      // Set defaults for optional fields
+      const job = {
+        ...config,
+        headers: config.headers || {},
+        body: config.body || {},
+        maxRetries: config.maxRetries || 3
+      }
+      this.jobsConfig.push(job)
+    }
+  }
+
+  start () {
+    for (const job of this.jobsConfig) {
+      this.logger.info(`Configuring scheduler "${job.name}" with cron "${job.cron}"`)
+      const cronJob = CronJob.from({
+        cronTime: job.cron,
+        onTick: async () => {
+          this.logger.info(`Executing scheduler "${job.name}"`)
+          // This cannot throw, the try/catch is inside
+          await this.executeCallback(job)
+        },
+        start: true,
+        timeZone: 'UTC',
+        waitForCompletion: true
+      })
+
+      this.cronJobs.push(cronJob)
+    }
+  }
+
+  async stop () {
+    for (const job of this.cronJobs) {
+      await job.stop()
+    }
+  }
+
+  async executeCallback (scheduler) {
+    let attempt = 0
+    let success = false
+
+    while (!success && attempt < scheduler.maxRetries) {
+      try {
+        const delay = attempt > 0 ? 100 * Math.pow(2, attempt) : 0
+
+        if (delay > 0) {
+          this.logger.info(
+            `Retrying scheduler "${scheduler.name}" in ${delay}ms (attempt ${attempt + 1}/${scheduler.maxRetries})`
+          )
+          await setTimeout(delay)
+        }
+        const headers = {
+          'x-retry-attempt': attempt + 1,
+          ...scheduler.headers
+        }
+
+        const bodyString = typeof scheduler.body === 'string' ? scheduler.body : JSON.stringify(scheduler.body)
+        const response = await request(scheduler.callbackUrl, {
+          method: scheduler.method,
+          headers,
+          body: bodyString,
+          dispatcher: this.dispatcher
+        })
+
+        // Consumes the body, but we are not interested in the body content,
+        // we don't save it anywere, so we just dump it
+        await response.body.dump()
+
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          this.logger.info(`Scheduler "${scheduler.name}" executed successfully`)
+          success = true
+        } else {
+          throw new Error(`HTTP error ${response.statusCode}`)
+        }
+      } catch (error) {
+        this.logger.error(
+          `Error executing scheduler "${scheduler.name}" (attempt ${attempt + 1}/${scheduler.maxRetries}):`,
+          error.message
+        )
+        attempt++
+      }
+    }
+
+    if (!success) {
+      this.logger.error(`Scheduler "${scheduler.name}" failed after ${scheduler.maxRetries} attempts`)
+    }
+  }
+}
+
+export function startScheduler (config, interceptors, logger) {
+  const schedulerService = new SchedulerService(config, interceptors, logger)
+  schedulerService.start()
+  return schedulerService
+}

package/lib/schema.js

@@ -1,250 +1,38 @@
 #! /usr/bin/env node
-'use strict'
 
-const telemetry = require('@platformatic/telemetry').schema
-const {
-  schemaComponents: { server, logger }
-} = require('@platformatic/utils')
+import { schemaComponents } from '@platformatic/foundation'
+import { version } from './version.js'
 
-const services = {
-  type: 'array',
-  items: {
-    type: 'object',
-    anyOf: [{ required: ['id', 'path'] }, { required: ['id', 'url'] }],
-    properties: {
-      id: {
-        type: 'string'
-      },
-      path: {
-        type: 'string',
-        resolvePath: true
-      },
-      config: {
-        type: 'string'
-      },
-      url: {
-        type: 'string'
-      },
-      useHttp: {
-        type: 'boolean'
-      }
+const runtimeLogger = {
+  ...schemaComponents.runtimeProperties.logger,
+  properties: {
+    ...schemaComponents.runtimeProperties.logger.properties,
+    captureStdio: {
+      type: 'boolean',
+      default: true
     }
   }
 }
 
-const pkg = require('../package.json')
+schemaComponents.runtimeProperties.logger = runtimeLogger
 
 const platformaticRuntimeSchema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`,
+  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
+  title: 'Platformatic Runtime Config',
   type: 'object',
-  properties: {
-    $schema: {
-      type: 'string'
-    },
-    preload: {
-      type: 'string',
-      resolvePath: true
-    },
-    entrypoint: {
-      type: 'string'
-    },
-    autoload: {
-      type: 'object',
-      additionalProperties: false,
-      required: ['path'],
-      properties: {
-        path: {
-          type: 'string',
-          resolvePath: true
-        },
-        exclude: {
-          type: 'array',
-          default: [],
-          items: {
-            type: 'string'
-          }
-        },
-        mappings: {
-          type: 'object',
-          additionalProperties: {
-            type: 'object',
-            additionalProperties: false,
-            required: ['id'],
-            properties: {
-              id: {
-                type: 'string'
-              },
-              config: {
-                type: 'string'
-              },
-              useHttp: {
-                type: 'boolean'
-              }
-            }
-          }
-        }
-      }
-    },
-    services,
-    web: services,
-    logger,
-    server,
-    restartOnError: {
-      default: true,
-      anyOf: [
-        { type: 'boolean' },
-        {
-          type: 'number',
-          minimum: 100
-        }
-      ]
-    },
-    undici: {
-      type: 'object',
-      properties: {
-        agentOptions: {
-          type: 'object',
-          additionalProperties: true
-        },
-        interceptors: {
-          anyOf: [
-            {
-              type: 'array',
-              items: {
-                $ref: '#/$defs/undiciInterceptor'
-              }
-            },
-            {
-              type: 'object',
-              properties: {
-                Client: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                },
-                Pool: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                },
-                Agent: {
-                  type: 'array',
-                  items: {
-                    $ref: '#/$defs/undiciInterceptor'
-                  }
-                }
-              }
-            }
-          ]
-        }
-      }
-    },
-    watch: {
-      anyOf: [
-        {
-          type: 'boolean'
-        },
-        {
-          type: 'string'
-        }
-      ]
-    },
-    managementApi: {
-      anyOf: [
-        { type: 'boolean' },
-        { type: 'string' },
-        {
-          type: 'object',
-          properties: {
-            logs: {
-              type: 'object',
-              properties: {
-                maxSize: {
-                  type: 'number',
-                  minimum: 5,
-                  default: 200
-                }
-              },
-              additionalProperties: false
-            }
-          },
-          additionalProperties: false
-        }
-      ],
-      default: true
-    },
-    metrics: {
-      anyOf: [
-        { type: 'boolean' },
-        {
-          type: 'object',
-          properties: {
-            port: {
-              anyOf: [{ type: 'integer' }, { type: 'string' }]
-            },
-            hostname: { type: 'string' },
-            endpoint: { type: 'string' },
-            auth: {
-              type: 'object',
-              properties: {
-                username: { type: 'string' },
-                password: { type: 'string' }
-              },
-              additionalProperties: false,
-              required: ['username', 'password']
-            },
-            labels: {
-              type: 'object',
-              additionalProperties: { type: 'string' }
-            }
-          },
-          additionalProperties: false
-        }
-      ]
-    },
-    telemetry,
-    inspectorOptions: {
-      type: 'object',
-      properties: {
-        host: {
-          type: 'string'
-        },
-        port: {
-          type: 'number'
-        },
-        breakFirstLine: {
-          type: 'boolean'
-        },
-        watchDisabled: {
-          type: 'boolean'
-        }
-      }
-    }
-  },
-  anyOf: [{ required: ['autoload'] }, { required: ['services'] }, { required: ['web'] }],
-  additionalProperties: false,
-  $defs: {
-    undiciInterceptor: {
-      type: 'object',
-      properties: {
-        module: {
-          type: 'string'
-        },
-        options: {
-          type: 'object',
-          additionalProperties: true
-        }
-      },
-      required: ['module', 'options']
-    }
-  }
+  properties: schemaComponents.runtimeProperties,
+  anyOf: [
+    { required: ['autoload'] },
+    { required: ['applications'] },
+    { required: ['services'] },
+    { required: ['web'] }
+  ],
+  additionalProperties: false
 }
 
-module.exports.schema = platformaticRuntimeSchema
+export const schema = platformaticRuntimeSchema
 
-if (require.main === module) {
+if (import.meta.main) {
   console.log(JSON.stringify(platformaticRuntimeSchema, null, 2))
 }

package/lib/shared-http-cache.js

@@ -0,0 +1,43 @@
+import { loadModule } from '@platformatic/foundation'
+import MemoryCacheStore from '@platformatic/undici-cache-memory'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+
+export async function createSharedStore (projectDir, httpCacheConfig = {}) {
+  const runtimeRequire = createRequire(join(projectDir, 'file'))
+
+  const { store, ...storeConfig } = httpCacheConfig
+  const CacheStore = store ? await loadModule(runtimeRequire, store) : MemoryCacheStore
+
+  class SharedCacheStore extends CacheStore {
+    async getValue (req) {
+      const cachedValue = await this.get(req)
+      if (!cachedValue) return null
+
+      const { body, ...response } = cachedValue
+
+      const acc = []
+      for await (const chunk of body) {
+        acc.push(chunk)
+      }
+
+      let payload
+      if (acc.length > 0 && typeof acc[0] === 'string') {
+        payload = acc.join('')
+      } else {
+        payload = Buffer.concat(acc)
+      }
+
+      return { response, payload }
+    }
+
+    setValue (req, opts, data) {
+      const writeStream = this.createWriteStream(req, opts)
+      writeStream.write(data)
+      writeStream.end()
+      return null
+    }
+  }
+
+  return new SharedCacheStore(storeConfig)
+}

package/lib/upgrade.js

@@ -1,15 +1,13 @@
-'use strict'
-
-const { join } = require('node:path')
-
-module.exports = async function upgrade (config, version) {
-  const { semgrator } = await import('semgrator')
+import { abstractLogger } from '@platformatic/foundation'
+import { join } from 'node:path'
+import { semgrator } from 'semgrator'
 
+export async function upgrade (logger, config, version) {
   const iterator = semgrator({
     version,
-    path: join(__dirname, 'versions'),
+    path: join(import.meta.dirname, 'versions'),
     input: config,
-    logger: this.logger.child({ name: '@platformatic/runtime' }),
+    logger: logger?.child({ name: '@platformatic/runtime' }) ?? abstractLogger
   })
 
   let result

package/lib/utils.js

@@ -1,74 +1,19 @@
-'use strict'
+import { createHash } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
-const { createHash } = require('node:crypto')
-const { tmpdir } = require('node:os')
-const { join } = require('node:path')
-
-const {
-  Store,
-  loadConfig: pltConfigLoadConfig,
-  loadEmptyConfig: pltConfigLoadEmptyConfig
-} = require('@platformatic/config')
-
-const { platformaticRuntime } = require('./config')
-
-function getArrayDifference (a, b) {
+export function getArrayDifference (a, b) {
   return a.filter(element => {
     return !b.includes(element)
   })
 }
 
-function getServiceUrl (id) {
+export function getApplicationUrl (id) {
   return `http://${id}.plt.local`
 }
 
-function getRuntimeTmpDir (runtimeDir) {
+export function getRuntimeTmpDir (runtimeDir) {
   const platformaticTmpDir = join(tmpdir(), 'platformatic', 'applications')
   const runtimeDirHash = createHash('md5').update(runtimeDir).digest('hex')
   return join(platformaticTmpDir, runtimeDirHash)
 }
-
-function getRuntimeLogsDir (runtimeDir, runtimePID) {
-  const runtimeTmpDir = getRuntimeTmpDir(runtimeDir)
-  return join(runtimeTmpDir, runtimePID.toString(), 'logs')
-}
-
-async function loadConfig (minimistConfig, args, overrides, replaceEnv = true) {
-  const { default: platformaticBasic } = await import('@platformatic/basic')
-  const store = new Store()
-  store.add(platformaticRuntime)
-
-  const id = platformaticRuntime.schema.$id.replace('@platformatic/runtime', 'wattpm')
-  const schema = {
-    ...platformaticRuntime.schema,
-    $id: id
-  }
-  const configManagerConfig = {
-    ...platformaticRuntime.configManagerConfig,
-    schema
-  }
-  const wattpm = {
-    ...platformaticRuntime,
-    schema,
-    configManagerConfig
-  }
-  store.add(wattpm)
-  store.add(platformaticBasic)
-
-  return pltConfigLoadConfig(minimistConfig, args, store, overrides, replaceEnv)
-}
-
-async function loadEmptyConfig (path, overrides, replaceEnv = true) {
-  const { default: platformaticBasic } = await import('@platformatic/basic')
-
-  return pltConfigLoadEmptyConfig(path, platformaticBasic, overrides, replaceEnv)
-}
-
-module.exports = {
-  getArrayDifference,
-  getRuntimeLogsDir,
-  getRuntimeTmpDir,
-  getServiceUrl,
-  loadConfig,
-  loadEmptyConfig
-}

package/lib/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf-8'))
+
+export const name = packageJson.name
+export const version = packageJson.version

package/lib/versions/v1.36.0.js

@@ -1,11 +1,9 @@
-'use strict'
-
-module.exports = {
+export default {
   version: '1.36.0',
   up: function (config) {
     if (config.restartOnError === undefined) {
       config.restartOnError = false
     }
     return config
-  },
+  }
 }

package/lib/versions/v1.5.0.js

@@ -1,11 +1,9 @@
-'use strict'
-
-module.exports = {
+export default {
   version: '1.5.0',
   up: function (config) {
     if (config.watch !== undefined) {
       delete config.watch
     }
     return config
-  },
+  }
 }

package/lib/versions/v2.0.0.js

@@ -1,8 +1,6 @@
-'use strict'
+import { version } from '../version.js'
 
-const pkg = require('../../package.json')
-
-module.exports = {
+export default {
   version: '1.99.0', // This is to account alpha versions as well
   up: function (config) {
     if (config.restartOnError === undefined) {
@@ -16,7 +14,7 @@ module.exports = {
 
     delete config.allowCycles
 
-    config.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`
+    config.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${version}.json`
 
     if (config.server?.logger) {
       config.logger = config.server.logger

package/lib/versions/v3.0.0.js

@@ -0,0 +1,16 @@
+export default {
+  version: '2.99.0',
+  up (config) {
+    if (typeof config.gracefulShutdown?.service === 'number') {
+      config.gracefulShutdown.application = config.gracefulShutdown.service
+      delete config.gracefulShutdown.service
+    }
+
+    if (typeof config.serviceTimeout === 'number') {
+      config.applicationTimeout = config.serviceTimeout
+      delete config.serviceTimeout
+    }
+
+    return config
+  }
+}