@platformatic/runtime 3.62.2 → 3.63.0-alpha.2

package/index.d.ts

@@ -58,6 +58,8 @@ export namespace errors {
   export const ReservedITCHandlerNameError: (name: string) => FastifyError
   export const DuplicateITCHandlerNameError: (name: string) => FastifyError
   export const LastProfileTimeoutError: (id: string) => FastifyError
+  export const SchedulerJobNotFoundError: (name: string) => FastifyError
+  export const DuplicateSchedulerJobError: (name: string) => FastifyError
 }
 
 export namespace symbols {
@@ -109,6 +111,45 @@ export interface ApplicationDetails {
   url?: string | null
 }
 
+export interface SchedulerJobBase {
+  name: string
+  cron: string
+  paused: boolean
+  maxRetries: number
+  lastExecutedAt?: string | null
+  lastStatus?: 'success' | 'failed' | null
+  nextRunAt?: string | null
+}
+
+export interface ConfiguredSchedulerJob extends SchedulerJobBase {
+  source: 'config'
+  callbackUrl: string
+  method: string
+  headers?: Record<string, string>
+  body?: string | Record<string, unknown>
+}
+
+export interface ApplicationSchedulerJob extends SchedulerJobBase {
+  source: 'application'
+  applicationId: string
+  scheduleId: string
+  tasks: string[]
+}
+
+export type SchedulerJob = ConfiguredSchedulerJob | ApplicationSchedulerJob
+
+export interface SchedulerRunResult {
+  name: string
+  success: boolean
+  executedAt: string
+}
+
+export interface ApplicationSchedule {
+  id: string
+  cron: string
+  tasks: string[]
+}
+
 export interface RuntimeMetadata {
   pid: number
   cwd: string
@@ -139,6 +180,10 @@ export declare class ManagementClient {
   getApplicationOpenapiSchema (id: string): Promise<unknown>
   getApplicationGraphqlSchema (id: string): Promise<unknown>
   getMetrics (format?: string): Promise<{ metrics: unknown }>
+  getScheduler (): Promise<SchedulerJob[]>
+  pauseSchedulerJob (name: string): Promise<SchedulerJob>
+  resumeSchedulerJob (name: string): Promise<SchedulerJob>
+  runSchedulerJob (name: string): Promise<SchedulerRunResult>
   startApplication (id: string): Promise<void>
   stopApplication (id: string): Promise<void>
   restartApplication (id: string): Promise<void>
@@ -198,6 +243,12 @@ export declare class Runtime extends EventEmitter {
   startApplicationProfiling (id: string, options?: Record<string, unknown>, ensureStarted?: boolean): Promise<void>
   stopApplicationProfiling (id: string, options?: Record<string, unknown>, ensureStarted?: boolean): Promise<Buffer>
   getApplicationLastProfile (id: string, options?: Record<string, unknown>, ensureStarted?: boolean): Promise<{ profile: Buffer, timestamp: number | null, preserved: boolean }>
+  getScheduler (): SchedulerJob[]
+  pauseSchedulerJob (name: string): Promise<SchedulerJob>
+  resumeSchedulerJob (name: string): Promise<SchedulerJob>
+  runSchedulerJob (name: string): Promise<SchedulerRunResult>
+  getApplicationScheduledTasks (id: string): Promise<ApplicationSchedule[]>
+  runApplicationScheduledTasks (id: string, scheduleId: string, scheduledTime: number): Promise<unknown>
 }
 
 export function wrapInRuntimeConfig (

package/lib/errors.js

@@ -140,6 +140,17 @@ export const MessagingError = createError(
   'Cannot send a message to application "%s": %s'
 )
 
+export const SchedulerJobNotFoundError = createError(
+  `${ERROR_PREFIX}_SCHEDULER_JOB_NOT_FOUND`,
+  'Scheduler "%s" not found',
+  404
+)
+
+export const DuplicateSchedulerJobError = createError(
+  `${ERROR_PREFIX}_DUPLICATE_SCHEDULER_JOB`,
+  'Scheduler "%s" is already registered'
+)
+
 export const MissingPprofCapture = createError(
   `${ERROR_PREFIX}_MISSING_PPROF_CAPTURE`,
   'Please install @platformatic/wattpm-pprof-capture'

package/lib/management-api.js

@@ -79,6 +79,23 @@ export async function managementApiPlugin (app, opts) {
     await runtime.restart(applications)
   })
 
+  app.get('/scheduler', async () => {
+    const jobs = await runtime.getScheduler()
+    return { jobs }
+  })
+
+  app.post('/scheduler/:name/pause', async request => {
+    return runtime.pauseSchedulerJob(request.params.name)
+  })
+
+  app.post('/scheduler/:name/resume', async request => {
+    return runtime.resumeSchedulerJob(request.params.name)
+  })
+
+  app.post('/scheduler/:name/run', async request => {
+    return runtime.runSchedulerJob(request.params.name)
+  })
+
   app.get('/applications', async () => {
     return runtime.getApplications()
   })

package/lib/management-handlers.js

@@ -19,6 +19,10 @@ const allOperations = [
   'getApplicationOpenapiSchema',
   'getApplicationGraphqlSchema',
   'getMetrics',
+  'getScheduler',
+  'pauseSchedulerJob',
+  'resumeSchedulerJob',
+  'runSchedulerJob',
   'startApplication',
   'stopApplication',
   'restartApplication',
@@ -96,6 +100,10 @@ export function createManagementHandlers (runtime, allowedOperations) {
     return runtime.getMetrics(format)
   })
 
+  register('getScheduler', async () => {
+    return runtime.getScheduler()
+  })
+
   // Write operations
   register('startApplication', async ({ id }) => {
     await runtime.startApplication(id)
@@ -113,6 +121,18 @@ export function createManagementHandlers (runtime, allowedOperations) {
     return runtime.restart(applications)
   })
 
+  register('pauseSchedulerJob', async ({ name }) => {
+    return runtime.pauseSchedulerJob(name)
+  })
+
+  register('resumeSchedulerJob', async ({ name }) => {
+    return runtime.resumeSchedulerJob(name)
+  })
+
+  register('runSchedulerJob', async ({ name }) => {
+    return runtime.runSchedulerJob(name)
+  })
+
   register('addApplications', async ({ applications, start }) => {
     const config = runtime.getRuntimeConfig(true)
 

package/lib/runtime.js

@@ -88,6 +88,7 @@ const kInspectorOptions = Symbol('plt.runtime.worker.inspectorOptions')
 const kHeapCheckCounter = Symbol('plt.runtime.worker.heapCheckCounter')
 const kLastHeapStats = Symbol('plt.runtime.worker.lastHeapStats')
 const kProfilingELUGates = Symbol('plt.runtime.worker.profilingELUGates')
+const kWorkerScheduledTasks = Symbol('plt.runtime.worker.scheduledTasks')
 const kHealthITCTimeoutMs = 5000
 const kProfilingELUHysteresis = 0.1
 const kLastProfileTimeoutMs = 10000
@@ -338,8 +339,8 @@ export class Runtime extends EventEmitter {
     await this.addApplications(this.#config.applications)
     await this.#setDispatcher(config.undici)
 
-    if (config.scheduler && !this.#context.build) {
-      this.#scheduler = startScheduler(config.scheduler, this.#dispatcher, logger)
+    if (!this.#context.build) {
+      this.#scheduler = startScheduler(config.scheduler ?? [], this.#dispatcher, logger)
     }
 
     this.#updateStatus('init')
@@ -651,13 +652,7 @@ export class Runtime extends EventEmitter {
 
     const removed = []
     for (const application of applications) {
-      if (!this.#applications.has(application)) {
-        throw new ApplicationNotFoundError(application, this.getApplicationsIds().join(', '))
-      }
-
-      // Use allowUnloaded so that applications without a live worker
-      // (stopped or crashed with restartOnError: 0) can still be removed.
-      const details = await this.getApplicationDetails(application, true)
+      const details = await this.getApplicationDetails(application)
       details.status = 'removed'
       removed.push(details)
     }
@@ -666,6 +661,7 @@ export class Runtime extends EventEmitter {
 
     for (const application of applications) {
       this.#dynamicWorkersScaler?.remove(application)
+      await this.#scheduler?.removeApplicationJobs(application)
       this.#applications.delete(application)
       this.#applicationRestartCounts.delete(application)
     }
@@ -774,6 +770,8 @@ export class Runtime extends EventEmitter {
       await this.#startWorker(config, applicationConfig, workers, id, i, silent)
     }
 
+    await this.#registerApplicationSchedulerJobs(id)
+
     this.emitAndNotify('application:started', id)
   }
 
@@ -786,6 +784,7 @@ export class Runtime extends EventEmitter {
     const workersCount = workersIds.length
 
     this.emitAndNotify('application:stopping', id)
+    await this.#scheduler?.stopApplicationJobs(id)
 
     if (typeof workersCount === 'number') {
       const stopInvocations = []
@@ -839,6 +838,7 @@ export class Runtime extends EventEmitter {
         await this.#replaceWorker(config, applicationConfig, workersCount, id, workerIndex, worker, true)
       }
 
+      await this.#registerApplicationSchedulerJobs(id)
       this.#incrementApplicationRestartCount(id)
       this.emitAndNotify('application:restarted', id)
     } finally {
@@ -1785,6 +1785,79 @@ export class Runtime extends EventEmitter {
     return sendViaITC(application, 'getApplicationGraphQLSchema')
   }
 
+  async getApplicationScheduledTasks (id) {
+    const application = await this.#getApplicationById(id, true)
+
+    return sendViaITC(application, 'getApplicationScheduledTasks')
+  }
+
+  async runApplicationScheduledTasks (id, scheduleId, scheduledTime) {
+    const application = await this.#getApplicationById(id, true)
+
+    return sendViaITC(application, 'runApplicationScheduledTasks', { scheduleId, scheduledTime })
+  }
+
+  getScheduler () {
+    return this.#scheduler?.getJobs() ?? []
+  }
+
+  pauseSchedulerJob (name) {
+    return this.#schedulerOrThrow().pauseJob(name)
+  }
+
+  resumeSchedulerJob (name) {
+    return this.#schedulerOrThrow().resumeJob(name)
+  }
+
+  runSchedulerJob (name) {
+    return this.#schedulerOrThrow().runJob(name)
+  }
+
+  #schedulerOrThrow () {
+    if (!this.#scheduler) {
+      throw new Error('The scheduler is not configured')
+    }
+
+    return this.#scheduler
+  }
+
+  async #registerApplicationSchedulerJobs (id) {
+    if (!this.#scheduler) {
+      return
+    }
+
+    const pausedJobs = new Set(
+      this.#scheduler
+        .getJobs()
+        .filter(job => job.applicationId === id && job.paused)
+        .map(job => job.name)
+    )
+
+    await this.#scheduler.removeApplicationJobs(id)
+
+    const workerId = this.#workers.getKeys(id)[0]
+    const schedules = this.#workers.get(workerId)?.[kWorkerScheduledTasks] ?? []
+    for (const schedule of schedules) {
+      const name = `${id}:${schedule.id}`
+      this.#scheduler.addJob(
+        {
+          name,
+          cron: schedule.cron,
+          source: 'application',
+          applicationId: id,
+          scheduleId: schedule.id,
+          tasks: schedule.tasks,
+          maxRetries: 3
+        },
+        ({ scheduledTime }) => this.runApplicationScheduledTasks(id, schedule.id, scheduledTime)
+      )
+
+      if (pausedJobs.has(name)) {
+        await this.#scheduler.pauseJob(name)
+      }
+    }
+  }
+
   async getWorkers (includeRaw = false) {
     const status = {}
 
@@ -2812,22 +2885,24 @@ export class Runtime extends EventEmitter {
     this.emitAndNotify('application:worker:starting', eventPayload)
 
     try {
-      let workerUrl
+      let workerStartResult
       if (config.startTimeout > 0) {
-        workerUrl = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
+        workerStartResult = await executeWithTimeout(sendViaITC(worker, 'start'), config.startTimeout)
 
-        if (workerUrl === kTimeout) {
+        if (workerStartResult === kTimeout) {
           this.emitAndNotify('application:worker:startTimeout', eventPayload)
           this.logger.error(`The ${label} failed to start in ${config.startTimeout}ms. Forcefully killing the thread.`)
           worker.terminate()
           throw new ApplicationStartTimeoutError(id, config.startTimeout)
         }
       } else {
-        workerUrl = await sendViaITC(worker, 'start')
+        workerStartResult = await sendViaITC(worker, 'start')
       }
 
       await this.#avoidOutOfOrderThreadLogs()
 
+      const { url: workerUrl, scheduledTasks } = workerStartResult
+      worker[kWorkerScheduledTasks] = scheduledTasks
       if (workerUrl) {
         this.#url = workerUrl
 
@@ -3144,7 +3219,17 @@ export class Runtime extends EventEmitter {
       this.#workers.set(newWorkerId, newWorker)
 
       // Add the worker to the mesh
-      await this.#startWorker(configForNewWorker, applicationConfig, workersCount, applicationId, newIndex, false, 0, newWorker, true)
+      await this.#startWorker(
+        configForNewWorker,
+        applicationConfig,
+        workersCount,
+        applicationId,
+        newIndex,
+        false,
+        0,
+        newWorker,
+        true
+      )
 
       // Make sure the runtime hasn't been stopped in the meanwhile
       if (this.#status !== 'started') {

package/lib/scheduler.js

@@ -1,68 +1,176 @@
 import { CronJob, validateCronExpression } from 'cron'
 import { setTimeout } from 'node:timers/promises'
 import { request } from 'undici'
+import { DuplicateSchedulerJobError, SchedulerJobNotFoundError } from './errors.js'
 
 export class SchedulerService {
   constructor (schedulerConfig, dispatcher, logger) {
     this.logger = logger
-    this.jobsConfig = []
-    this.cronJobs = []
     this.dispatcher = dispatcher
-    this.validateCronSchedulers(schedulerConfig)
-  }
+    this.jobs = new Map()
+    this.started = false
 
-  validateCronSchedulers (schedulerConfig) {
     for (const config of schedulerConfig) {
-      // Skip disabled schedulers
-      if (config.enabled === false) {
-        continue
-      }
+      this.addJob({ ...config, source: 'config' })
+    }
+  }
 
-      // Validate cron expression
-      const validation = validateCronExpression(config.cron)
-      if (!validation.valid) {
-        throw new Error(`Invalid cron expression "${config.cron}" for scheduler "${config.name}"`)
-      }
+  addJob (config, executor) {
+    // Skip disabled schedulers
+    if (config.enabled === false) {
+      return null
+    }
 
-      // Set defaults for optional fields
-      const job = {
-        ...config,
-        headers: config.headers || {},
-        body: config.body || {},
-        maxRetries: config.maxRetries || 3
-      }
-      this.jobsConfig.push(job)
+    // 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,
+      source: config.source ?? 'application',
+      paused: false,
+      lastExecutedAt: null,
+      lastStatus: null,
+      cronJob: null,
+      executor
     }
+
+    if (this.jobs.has(job.name)) {
+      throw new DuplicateSchedulerJobError(job.name)
+    }
+
+    this.jobs.set(job.name, job)
+
+    if (this.started) {
+      this.#startJob(job)
+    }
+
+    return this.#serializeJob(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)
+    this.started = true
+
+    for (const job of this.jobs.values()) {
+      this.#startJob(job)
     }
   }
 
   async stop () {
-    for (const job of this.cronJobs) {
-      await job.stop()
+    this.started = false
+
+    for (const job of this.jobs.values()) {
+      await this.#stopJob(job)
+    }
+  }
+
+  getJobs () {
+    return Array.from(this.jobs.values(), job => this.#serializeJob(job))
+  }
+
+  // Stops the local cron trigger for a job without removing its configuration.
+  // Used when an external coordinator (e.g. ICC) takes over the scheduling, so
+  // that multiple instances of the same runtime do not execute the job concurrently.
+  async pauseJob (name) {
+    const job = this.#getJobOrThrow(name)
+
+    if (job.paused) {
+      return this.#serializeJob(job)
+    }
+
+    job.paused = true
+    await this.#stopJob(job)
+    this.logger.info(`Scheduler "${name}" paused`)
+    return this.#serializeJob(job)
+  }
+
+  async resumeJob (name) {
+    const job = this.#getJobOrThrow(name)
+
+    if (!job.paused) {
+      return this.#serializeJob(job)
+    }
+
+    job.paused = false
+
+    if (this.started) {
+      this.#startJob(job)
+    }
+
+    this.logger.info(`Scheduler "${name}" resumed`)
+    return this.#serializeJob(job)
+  }
+
+  async removeApplicationJobs (applicationId) {
+    for (const [name, job] of this.jobs) {
+      if (job.applicationId === applicationId) {
+        await this.#stopJob(job)
+        this.jobs.delete(name)
+      }
+    }
+  }
+
+  async stopApplicationJobs (applicationId) {
+    for (const job of this.jobs.values()) {
+      if (job.applicationId === applicationId) {
+        await this.#stopJob(job)
+      }
+    }
+  }
+
+  // Executes a job immediately, regardless of its cron schedule or paused state.
+  // Used by an external coordinator to trigger the execution in this instance.
+  async runJob (name) {
+    const job = this.#getJobOrThrow(name)
+    return this.executeCallback(job)
+  }
+
+  #getJobOrThrow (name) {
+    const job = this.jobs.get(name)
+    if (!job) {
+      throw new SchedulerJobNotFoundError(name)
+    }
+    return job
+  }
+
+  #startJob (job) {
+    if (job.cronJob || job.paused) {
+      return
+    }
+
+    this.logger.info(`Configuring scheduler "${job.name}" with cron "${job.cron}"`)
+    job.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
+    })
+  }
+
+  async #stopJob (job) {
+    if (!job.cronJob) {
+      return
     }
+
+    await job.cronJob.stop()
+    job.cronJob = null
   }
 
   async executeCallback (scheduler) {
     let attempt = 0
     let success = false
+    const scheduledTime = Date.now()
 
     while (!success && attempt < scheduler.maxRetries) {
       try {
@@ -74,29 +182,32 @@ export class SchedulerService {
           )
           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
+        if (scheduler.executor) {
+          await scheduler.executor({ scheduledTime })
         } else {
-          throw new Error(`HTTP error ${response.statusCode}`)
+          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
+          })
+
+          // Consume the body to release the connection.
+          await response.body.dump()
+
+          if (response.statusCode < 200 || response.statusCode >= 300) {
+            throw new Error(`HTTP error ${response.statusCode}`)
+          }
         }
+
+        this.logger.info(`Scheduler "${scheduler.name}" executed successfully`)
+        success = true
       } catch (error) {
         this.logger.error(
           `Error executing scheduler "${scheduler.name}" (attempt ${attempt + 1}/${scheduler.maxRetries}):`,
@@ -106,9 +217,30 @@ export class SchedulerService {
       }
     }
 
+    scheduler.lastExecutedAt = new Date().toISOString()
+    scheduler.lastStatus = success ? 'success' : 'failed'
+
     if (!success) {
       this.logger.error(`Scheduler "${scheduler.name}" failed after ${scheduler.maxRetries} attempts`)
     }
+
+    return { name: scheduler.name, success, executedAt: scheduler.lastExecutedAt }
+  }
+
+  #serializeJob (job) {
+    const { cronJob, executor, ...serializable } = job
+    let nextRunAt = null
+
+    if (cronJob) {
+      try {
+        nextRunAt = cronJob.nextDate().toJSDate().toISOString()
+        /* c8 ignore next 3 */
+      } catch {
+        nextRunAt = null
+      }
+    }
+
+    return { ...serializable, nextRunAt }
   }
 }
 

package/lib/worker/itc.js

@@ -195,7 +195,16 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         }
 
         dispatcher.replaceServer(await controller.capability.getDispatchTarget())
-        return application.entrypoint ? controller.capability.getUrl() : null
+
+        const scheduledTasks =
+          typeof controller.capability.getScheduledTasks === 'function'
+            ? await controller.capability.getScheduledTasks()
+            : []
+
+        return {
+          url: application.entrypoint ? controller.capability.getUrl() : null,
+          scheduledTasks
+        }
       },
 
       async stop ({ force, dependents }) {
@@ -286,6 +295,22 @@ export async function setupITC (controller, application, dispatcher, sharedConte
         }
       },
 
+      async getApplicationScheduledTasks () {
+        if (typeof controller.capability.getScheduledTasks !== 'function') {
+          return []
+        }
+
+        return controller.capability.getScheduledTasks()
+      },
+
+      async runApplicationScheduledTasks ({ scheduleId, scheduledTime }) {
+        if (typeof controller.capability.runScheduledTasks !== 'function') {
+          throw new Error(`Application "${application.id}" does not support scheduled task execution`)
+        }
+
+        return controller.capability.runScheduledTasks(scheduleId, scheduledTime)
+      },
+
       async getApplicationMeta () {
         try {
           return await controller.capability.getMeta()

package/lib/worker/management.js

@@ -70,6 +70,22 @@ export class ManagementClient {
     return this.#send('getMetrics', { format })
   }
 
+  getScheduler () {
+    return this.#send('getScheduler')
+  }
+
+  pauseSchedulerJob (name) {
+    return this.#send('pauseSchedulerJob', { name })
+  }
+
+  resumeSchedulerJob (name) {
+    return this.#send('resumeSchedulerJob', { name })
+  }
+
+  runSchedulerJob (name) {
+    return this.#send('runSchedulerJob', { name })
+  }
+
   startApplication (id) {
     return this.#send('startApplication', { id })
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "3.62.2",
+  "version": "3.63.0-alpha.2",
   "description": "Platformatic runtime",
   "main": "index.js",
   "type": "module",
@@ -39,14 +39,14 @@
     "typescript": "^5.9.3",
     "undici-oidc-interceptor": "^0.9.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/db": "3.62.2",
-    "@platformatic/gateway": "3.62.2",
-    "@platformatic/node": "3.62.2",
-    "@platformatic/service": "3.62.2",
-    "@platformatic/composer": "3.62.2",
-    "@platformatic/sql-graphql": "3.62.2",
-    "@platformatic/sql-mapper": "3.62.2",
-    "@platformatic/wattpm-pprof-capture": "3.62.2"
+    "@platformatic/composer": "3.63.0-alpha.2",
+    "@platformatic/db": "3.63.0-alpha.2",
+    "@platformatic/gateway": "3.63.0-alpha.2",
+    "@platformatic/node": "3.63.0-alpha.2",
+    "@platformatic/sql-graphql": "3.63.0-alpha.2",
+    "@platformatic/service": "3.63.0-alpha.2",
+    "@platformatic/wattpm-pprof-capture": "3.63.0-alpha.2",
+    "@platformatic/sql-mapper": "3.63.0-alpha.2"
   },
   "dependencies": {
     "@fastify/accepts": "^5.0.0",
@@ -77,13 +77,13 @@
     "undici": "^7.27.2",
     "undici-thread-interceptor": "^1.3.1",
     "ws": "^8.16.0",
-    "@platformatic/basic": "3.62.2",
-    "@platformatic/foundation": "3.62.2",
-    "@platformatic/itc": "3.62.2",
-    "@platformatic/globals": "3.62.2",
-    "@platformatic/generators": "3.62.2",
-    "@platformatic/metrics": "3.62.2",
-    "@platformatic/telemetry": "3.62.2"
+    "@platformatic/basic": "3.63.0-alpha.2",
+    "@platformatic/foundation": "3.63.0-alpha.2",
+    "@platformatic/generators": "3.63.0-alpha.2",
+    "@platformatic/globals": "3.63.0-alpha.2",
+    "@platformatic/metrics": "3.63.0-alpha.2",
+    "@platformatic/telemetry": "3.63.0-alpha.2",
+    "@platformatic/itc": "3.63.0-alpha.2"
   },
   "engines": {
     "node": ">=22.19.0"

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.62.2.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/runtime/3.63.0-alpha.2.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Runtime Config",
   "type": "object",