@platformatic/next 2.19.0 → 2.20.0-alpha.1

package/config.d.ts

@@ -93,4 +93,10 @@ export interface PlatformaticNextJsStackable {
       production?: string;
     };
   };
+  cache?: {
+    adapter: "redis" | "valkey";
+    url: string;
+    prefix?: string;
+    maxTTL?: number | string;
+  };
 }

package/index.js

@@ -21,6 +21,8 @@ import { packageJson, schema } from './lib/schema.js'
 
 const supportedVersions = ['^14.0.0', '^15.0.0']
 
+export * as cachingValkey from './lib/caching/valkey.js'
+
 export class NextStackable extends BaseStackable {
   #basePath
   #next
@@ -61,8 +63,10 @@ export class NextStackable extends BaseStackable {
       return this.stopCommand()
     }
 
+    globalThis.platformatic.events.emit('plt:next:close')
+
     if (this.isProduction) {
-      return new Promise((resolve, reject) => {
+      await new Promise((resolve, reject) => {
         this.#server.close(error => {
           /* c8 ignore next 3 */
           if (error) {
@@ -72,6 +76,8 @@ export class NextStackable extends BaseStackable {
           resolve()
         })
       })
+
+      await this.childManager.close()
     } else {
       const exitPromise = once(this.#child, 'exit')
       await this.childManager.close()
@@ -102,7 +108,8 @@ export class NextStackable extends BaseStackable {
   /* c8 ignore next 5 */
   async getWatchConfig () {
     return {
-      enabled: false
+      enabled: false,
+      path: this.root
     }
   }
 
@@ -137,6 +144,7 @@ export class NextStackable extends BaseStackable {
     this.childManager = new ChildManager({
       loader: loaderUrl,
       context: {
+        config: this.configManager.current,
         serviceId: this.serviceId,
         workerId: this.workerId,
         // Always use URL to avoid serialization problem in Windows
@@ -200,6 +208,7 @@ export class NextStackable extends BaseStackable {
     this.childManager = new ChildManager({
       loader: loaderUrl,
       context: {
+        config: this.configManager.current,
         serviceId: this.serviceId,
         workerId: this.workerId,
         // Always use URL to avoid serialization problem in Windows
@@ -220,6 +229,7 @@ export class NextStackable extends BaseStackable {
 
   async #startProductionNext () {
     try {
+      globalThis.platformatic.config = this.configManager.current
       await this.childManager.inject()
       const { nextStart } = await importFile(pathResolve(this.#next, './dist/cli/next-start.js'))
 
@@ -278,6 +288,10 @@ function transformConfig () {
     this.current.watch = { enabled: this.current.watch || false }
   }
 
+  if (this.current.cache?.adapter === 'redis') {
+    this.current.cache.adapter = 'valkey'
+  }
+
   basicTransformConfig.call(this)
 }
 

package/lib/caching/valkey.js

@@ -0,0 +1,229 @@
+import { ensureLoggableError } from '@platformatic/utils'
+import { Redis } from 'iovalkey'
+import { pack, unpack } from 'msgpackr'
+import { existsSync, readFileSync } from 'node:fs'
+import { hostname } from 'node:os'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { pino } from 'pino'
+
+export const MAX_BATCH_SIZE = 100
+
+export const sections = {
+  values: 'values',
+  tags: 'tags'
+}
+
+const clients = new Map()
+
+export function keyFor (prefix, subprefix, section, key) {
+  return [prefix, 'cache:next', subprefix, section, key ? Buffer.from(key).toString('base64url') : undefined]
+    .filter(c => c)
+    .join(':')
+}
+
+export function getConnection (url) {
+  let client = clients.get(url)
+
+  if (!client) {
+    client = new Redis(url, { enableAutoPipelining: true })
+    clients.set(url, client)
+
+    globalThis.platformatic.events.on('plt:next:close', () => {
+      client.disconnect(false)
+    })
+  }
+
+  return client
+}
+
+export class CacheHandler {
+  #config
+  #logger
+  #store
+  #subprefix
+  #maxTTL
+
+  constructor () {
+    this.#logger = this.#createLogger()
+    this.#config = globalThis.platformatic.config.cache
+    this.#store = getConnection(this.#config.url)
+    this.#maxTTL = this.#config.maxTTL
+    this.#subprefix = this.#getSubprefix()
+  }
+
+  async get (cacheKey) {
+    this.#logger.trace({ key: cacheKey }, 'get')
+
+    const key = this.#keyFor(cacheKey, sections.values)
+
+    let rawValue
+    try {
+      rawValue = await this.#store.get(key)
+
+      if (!rawValue) {
+        return
+      }
+    } catch (e) {
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot read cache value from Valkey')
+      throw new Error('Cannot read cache value from Valkey', { cause: e })
+    }
+
+    let value
+    try {
+      value = this.#deserialize(rawValue)
+    } catch (e) {
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot deserialize cache value from Valkey')
+
+      // Avoid useless reads the next time
+      // Note that since the value was unserializable, we don't know its tags and thus
+      // we cannot remove it from the tags sets. TTL will take care of them.
+      await this.#store.del(key)
+
+      throw new Error('Cannot deserialize cache value from Valkey', { cause: e })
+    }
+
+    if (this.#maxTTL < value.revalidate) {
+      try {
+        await this.#refreshKey(key, value)
+      } catch (e) {
+        this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot refresh cache key expiration in Valkey')
+
+        // We don't throw here since we want to use the cached value anyway
+      }
+    }
+
+    return value
+  }
+
+  async set (cacheKey, value, { tags, revalidate }) {
+    this.#logger.trace({ key: cacheKey, value, tags, revalidate }, 'set')
+
+    try {
+      // Compute the parameters to save
+      const key = this.#keyFor(cacheKey, sections.values)
+      const data = this.#serialize({ value, tags, lastModified: Date.now(), revalidate, maxTTL: this.#maxTTL })
+      const expire = Math.min(revalidate, this.#maxTTL)
+
+      if (expire < 1) {
+        return
+      }
+
+      // Enqueue all the operations to perform in Valkey
+
+      const promises = []
+      promises.push(this.#store.set(key, data, 'EX', expire))
+
+      // As Next.js limits tags to 64, we don't need to manage batches here
+      if (Array.isArray(tags)) {
+        for (const tag of tags) {
+          const tagsKey = this.#keyFor(tag, sections.tags)
+          promises.push(this.#store.sadd(tagsKey, key))
+          promises.push(this.#store.expire(tagsKey, expire))
+        }
+      }
+
+      // Execute all the operations
+      await Promise.all(promises)
+    } catch (e) {
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot write cache value in Valkey')
+      throw new Error('Cannot write cache value in Valkey', { cause: e })
+    }
+  }
+
+  async revalidateTag (tags) {
+    this.#logger.trace({ tags }, 'revalidateTag')
+
+    if (typeof tags === 'string') {
+      tags = [tags]
+    }
+
+    try {
+      let promises = []
+
+      for (const tag of tags) {
+        const tagsKey = this.#keyFor(tag, sections.tags)
+
+        // For each key in the tag set, expire the key
+        for await (const keys of this.#store.sscanStream(tagsKey)) {
+          for (const key of keys) {
+            promises.push(this.#store.del(key))
+
+            // Batch full, execute it
+            if (promises.length >= MAX_BATCH_SIZE) {
+              await Promise.all(promises)
+              promises = []
+            }
+          }
+        }
+
+        // Delete the set, this will also take care of executing pending operation for a non full batch
+        promises.push(this.#store.del(tagsKey))
+        await Promise.all(promises)
+        promises = []
+      }
+    } catch (e) {
+      this.#logger.error({ err: ensureLoggableError(e) }, 'Cannot expire cache tags in Valkey')
+      throw new Error('Cannot expire cache tags in Valkey', { cause: e })
+    }
+  }
+
+  async #refreshKey (key, value) {
+    const life = Math.round((Date.now() - value.lastModified) / 1000)
+    const expire = Math.min(value.revalidate - life, this.#maxTTL)
+
+    if (expire < 1) {
+      return
+    }
+
+    const promises = []
+    promises.push(this.#store.expire(key, expire, 'gt'))
+
+    if (Array.isArray(value.tags)) {
+      for (const tag of value.tags) {
+        const tagsKey = this.#keyFor(tag, sections.tags)
+        promises.push(this.#store.expire(tagsKey, expire, 'gt'))
+      }
+    }
+
+    await Promise.all(promises)
+  }
+
+  #createLogger () {
+    const pinoOptions = {
+      level: globalThis.platformatic?.logLevel ?? 'info'
+    }
+
+    if (this.serviceId) {
+      pinoOptions.name = `cache:${this.serviceId}`
+    }
+
+    if (typeof globalThis.platformatic.workerId !== 'undefined') {
+      pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: this.workerId }
+    }
+
+    return pino(pinoOptions)
+  }
+
+  #getSubprefix () {
+    const root = fileURLToPath(globalThis.platformatic.root)
+
+    return existsSync(resolve(root, '.next/BUILD_ID'))
+      ? (this.#subprefix = readFileSync(resolve(root, '.next/BUILD_ID'), 'utf-8').trim())
+      : 'development'
+  }
+
+  #keyFor (key, section) {
+    return keyFor(this.#config.prefix, this.#subprefix, section, key)
+  }
+
+  #serialize (data) {
+    return pack(data).toString('base64url')
+  }
+
+  #deserialize (data) {
+    return unpack(Buffer.from(data, 'base64url'))
+  }
+}
+
+export default CacheHandler

package/lib/loader.js

@@ -11,10 +11,12 @@ import {
   variableDeclarator
 } from '@babel/types'
 import { readFile, realpath } from 'node:fs/promises'
+import { sep } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const originalId = '__pltOriginalNextConfig'
 
+let config
 let candidates
 let basePath = ''
 
@@ -35,6 +37,11 @@ function parseSingleExpression (expr) {
       __pltOriginalNextConfig.basePath = basePath
     }
 
+    if(typeof __pltOriginalNextConfig.cacheHandler === 'undefined') {
+      __pltOriginalNextConfig.cacheHandler = $PATH
+      __pltOriginalNextConfig.cacheMaxMemorySize = 0
+    }
+
     // This is to send the configuraion when Next is executed in a child process (development)
     globalThis[Symbol.for('plt.children.itc')]?.notify('config', __pltOriginalNextConfig)
 
@@ -45,21 +52,35 @@ function parseSingleExpression (expr) {
   }
 */
 function createEvaluatorWrapperFunction (original) {
+  const cacheHandler = config?.cache?.adapter
+    ? fileURLToPath(new URL(`./caching/${config.cache.adapter}.js`, import.meta.url)).replaceAll(sep, '/')
+    : undefined
+
   return functionDeclaration(
     null,
     [restElement(identifier('args'))],
-    blockStatement([
-      variableDeclaration('let', [variableDeclarator(identifier(originalId), original)]),
-      parseSingleExpression(
-        `if (typeof ${originalId} === 'function') { ${originalId} = await ${originalId}(...args) }`
-      ),
-      parseSingleExpression(
-        `if (typeof ${originalId}.basePath === 'undefined') { ${originalId}.basePath = "${basePath}" }`
-      ),
-      parseSingleExpression(`globalThis[Symbol.for('plt.children.itc')]?.notify('config', ${originalId})`),
-      parseSingleExpression(`process.emit('plt:next:config', ${originalId})`),
-      returnStatement(identifier(originalId))
-    ]),
+    blockStatement(
+      [
+        variableDeclaration('let', [variableDeclarator(identifier(originalId), original)]),
+        parseSingleExpression(
+          `if (typeof ${originalId} === 'function') { ${originalId} = await ${originalId}(...args) }`
+        ),
+        parseSingleExpression(
+          `if (typeof ${originalId}.basePath === 'undefined') { ${originalId}.basePath = "${basePath}" }`
+        ),
+        cacheHandler
+          ? parseSingleExpression(`
+              if (typeof ${originalId}.cacheHandler === 'undefined') {
+                ${originalId}.cacheHandler = '${cacheHandler}'
+                ${originalId}.cacheMaxMemorySize = 0
+              }  
+            `)
+          : undefined,
+        parseSingleExpression(`globalThis[Symbol.for('plt.children.itc')]?.notify('config', ${originalId})`),
+        parseSingleExpression(`process.emit('plt:next:config', ${originalId})`),
+        returnStatement(identifier(originalId))
+      ].filter(e => e)
+    ),
     false,
     true
   )
@@ -125,6 +146,7 @@ export async function initialize (data) {
   // Keep in sync with https://github.com/vercel/next.js/blob/main/packages/next/src/shared/lib/constants.ts
   candidates = ['next.config.js', 'next.config.mjs'].map(c => new URL(c, realRoot).toString())
   basePath = data.basePath ?? ''
+  config = data.config
 }
 
 export async function load (url, context, nextLoad) {

package/lib/schema.js

@@ -4,6 +4,36 @@ import { readFileSync } from 'node:fs'
 
 export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
 
+export const cache = {
+  type: 'object',
+  properties: {
+    adapter: {
+      type: 'string',
+      enum: ['redis', 'valkey']
+    },
+    url: {
+      type: 'string'
+    },
+    prefix: {
+      type: 'string'
+    },
+    maxTTL: {
+      default: 86400 * 7, // One week
+      anyOf: [
+        {
+          type: 'number',
+          minimum: 0
+        },
+        {
+          type: 'string'
+        }
+      ]
+    }
+  },
+  required: ['adapter', 'url'],
+  additionalProperties: false
+}
+
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/next/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
@@ -16,7 +46,8 @@ export const schema = {
     logger: utilsSchemaComponents.logger,
     server: utilsSchemaComponents.server,
     watch: schemaComponents.watch,
-    application: schemaComponents.application
+    application: schemaComponents.application,
+    cache
   },
   additionalProperties: false
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/next",
-  "version": "2.19.0",
+  "version": "2.20.0-alpha.1",
   "description": "Platformatic Next.js Stackable",
   "main": "index.js",
   "type": "module",
@@ -20,10 +20,12 @@
     "@babel/traverse": "^7.25.3",
     "@babel/types": "^7.25.2",
     "amaro": "^0.2.0",
+    "iovalkey": "^0.2.1",
+    "msgpackr": "^1.11.2",
     "semver": "^7.6.3",
-    "@platformatic/basic": "2.19.0",
-    "@platformatic/config": "2.19.0",
-    "@platformatic/utils": "2.19.0"
+    "@platformatic/basic": "2.20.0-alpha.1",
+    "@platformatic/config": "2.20.0-alpha.1",
+    "@platformatic/utils": "2.20.0-alpha.1"
   },
   "devDependencies": {
     "@fastify/reply-from": "^11.0.0",
@@ -39,8 +41,8 @@
     "react-dom": "^18.3.1",
     "typescript": "^5.5.4",
     "ws": "^8.18.0",
-    "@platformatic/composer": "2.19.0",
-    "@platformatic/service": "2.19.0"
+    "@platformatic/composer": "2.20.0-alpha.1",
+    "@platformatic/service": "2.20.0-alpha.1"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --no-timeout",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/next/2.19.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/next/2.20.0-alpha.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Next.js Stackable",
   "type": "object",
@@ -296,6 +296,41 @@
       },
       "additionalProperties": false,
       "default": {}
+    },
+    "cache": {
+      "type": "object",
+      "properties": {
+        "adapter": {
+          "type": "string",
+          "enum": [
+            "redis",
+            "valkey"
+          ]
+        },
+        "url": {
+          "type": "string"
+        },
+        "prefix": {
+          "type": "string"
+        },
+        "maxTTL": {
+          "default": 604800,
+          "anyOf": [
+            {
+              "type": "number",
+              "minimum": 0
+            },
+            {
+              "type": "string"
+            }
+          ]
+        }
+      },
+      "required": [
+        "adapter",
+        "url"
+      ],
+      "additionalProperties": false
     }
   },
   "additionalProperties": false