nvent 0.4.0

package/dist/runtime/server/plugins/00.ws-lifecycle.js

@@ -0,0 +1,66 @@
+import {
+  defineNitroPlugin,
+  getActivePeerCount,
+  getActivePeers,
+  setShuttingDown,
+  clearAllPeers,
+  isServerShuttingDown,
+  useServerLogger
+} from "#imports";
+const logger = useServerLogger("plugin-ws-lifecycle");
+export default defineNitroPlugin((nitroApp) => {
+  logger.info("[ws-lifecycle] WebSocket lifecycle plugin initialized");
+  const originalUnhandledRejection = process.listeners("unhandledRejection");
+  nitroApp.hooks.hook("close", async () => {
+    setShuttingDown(true);
+    const peerCount = getActivePeerCount();
+    if (peerCount === 0) {
+      logger.info("[ws-lifecycle] No active WebSocket connections to close");
+      return;
+    }
+    logger.info(`[ws-lifecycle] Closing ${peerCount} active WebSocket connections...`);
+    const closePromises = [];
+    const peers = getActivePeers();
+    for (const peer of peers) {
+      closePromises.push(
+        new Promise((resolve) => {
+          try {
+            peer.send(JSON.stringify({
+              type: "server-restart",
+              message: "Server is restarting (HMR)"
+            }));
+            setTimeout(() => {
+              try {
+                peer.close(1001, "Server restarting");
+              } catch {
+              }
+              resolve();
+            }, 200);
+          } catch {
+            try {
+              peer.close(1001, "Server restarting");
+            } catch {
+            }
+            resolve();
+          }
+        })
+      );
+    }
+    await Promise.all(closePromises);
+    clearAllPeers();
+    logger.info("[ws-lifecycle] All WebSocket connections closed");
+    setTimeout(() => {
+      setShuttingDown(false);
+    }, 500);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isServerShuttingDown() && reason?.code === "ECONNRESET") {
+      return;
+    }
+    for (const handler of originalUnhandledRejection) {
+      if (typeof handler === "function") {
+        handler(reason, Promise.reject(reason));
+      }
+    }
+  });
+});

package/dist/runtime/server/plugins/flow-management.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Flow Management Plugin
+ *
+ * Handles NEW flow starts from external triggers:
+ * - Processes external triggers to start new flows
+ * - Emits flow.start events for new flow runs
+ * - Maps flowIds to flowNames
+ *
+ * Note: Step orchestration (checking dependencies, triggering next steps)
+ * is handled by flowWiring.ts which subscribes to emit/step.completed events
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/flow-management.js

@@ -0,0 +1,65 @@
+import { defineNitroPlugin, useEventManager, $useQueueRegistry, useQueue, useServerLogger } from "#imports";
+const logger = useServerLogger("plugin-flow-management");
+export default defineNitroPlugin((nitro) => {
+  const { onType, publishBus } = useEventManager();
+  const registry = $useQueueRegistry();
+  const flowIdToName = /* @__PURE__ */ new Map();
+  const getFlowNameById = (id) => {
+    const cached = flowIdToName.get(id);
+    if (cached) return cached;
+    try {
+      const flows = registry?.flows || {};
+      for (const [name, def] of Object.entries(flows)) {
+        if (def?.id === id) {
+          flowIdToName.set(id, name);
+          return name;
+        }
+      }
+    } catch {
+    }
+    return void 0;
+  };
+  const unsubscribes = [];
+  unsubscribes.push(onType("emit", async (e) => {
+    if (e.runId) return;
+    const emitName = e.data?.name;
+    if (!emitName) return;
+    const triggers = Object.keys(registry?.eventIndex || {});
+    if (!triggers.includes(emitName)) return;
+    const { enqueue } = useQueue();
+    const targets = (registry?.eventIndex)[emitName] || [];
+    for (const t of targets) {
+      const payload = { ...e.data };
+      try {
+        const id = await enqueue(t.queue, { name: t.step, data: payload });
+        try {
+          const targetFlowName = getFlowNameById(String(t.flowId)) || String(t.flowId);
+          const newRunId = String(id);
+          await publishBus({
+            type: "flow.start",
+            runId: newRunId,
+            flowName: targetFlowName,
+            data: { input: payload }
+          });
+          if (process.env.NQ_DEBUG_EVENTS === "1") {
+            logger.info("[flow-lifecycle] started new flow:", {
+              flowName: targetFlowName,
+              runId: newRunId,
+              entryStep: t.step
+            });
+          }
+        } catch {
+        }
+      } catch (err) {
+        logger.warn("[flow-lifecycle] failed to start flow:", {
+          step: t.step,
+          error: err?.message
+        });
+      }
+    }
+  }));
+  nitro.hooks.hook("close", () => {
+    unsubscribes.forEach((fn) => fn());
+    flowIdToName.clear();
+  });
+});

package/dist/runtime/server/plugins/queue-management.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/queue-management.js

@@ -0,0 +1,27 @@
+import { defineNitroPlugin, useServerLogger } from "#imports";
+import { BullMQProvider } from "../queue/adapters/bullmq.js";
+import { setQueueProvider, getQueueProvider } from "../queue/queueFactory.js";
+const logger = useServerLogger("plugin-queue-management");
+export default defineNitroPlugin(async (nitroApp) => {
+  try {
+    const existingProvider = getQueueProvider();
+    if (existingProvider) {
+      logger.info("[queues plugin] Closing existing queue provider before creating new one...");
+      await existingProvider.close();
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  } catch {
+  }
+  const provider = new BullMQProvider();
+  await provider.init();
+  setQueueProvider(provider);
+  nitroApp.hooks.hook("close", async () => {
+    logger.info("[queues plugin] Closing queue provider...");
+    await provider.close();
+  });
+  return {
+    async close() {
+      await provider.close();
+    }
+  };
+});

package/dist/runtime/server/plugins/state-cleanup.d.ts

@@ -0,0 +1,11 @@
+/**
+ * State Cleanup Plugin
+ *
+ * Handles automatic cleanup of flow state based on configuration strategy:
+ * - 'never': State persists indefinitely
+ * - 'immediate': Cleanup after each step (original behavior, not recommended)
+ * - 'on-complete': Cleanup when flow completes (recommended, uses lifecycle tracking)
+ * - 'ttl': State expires automatically via TTL (handled by storage provider)
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/state-cleanup.js

@@ -0,0 +1,93 @@
+import { useServerLogger, defineNitroPlugin, useEventManager, useRuntimeConfig } from "#imports";
+import { getStateProvider } from "../state/stateFactory.js";
+const logger = useServerLogger("plugin-state-cleanup");
+export default defineNitroPlugin(() => {
+  const rc = useRuntimeConfig();
+  const cleanup = rc?.queue?.state?.cleanup || { strategy: "never" };
+  if (cleanup.strategy === "never" || cleanup.strategy === "ttl") {
+    return;
+  }
+  const { onType } = useEventManager();
+  const unsubs = [];
+  if (cleanup.strategy === "on-complete") {
+    unsubs.push(onType("flow.completed", async (event) => {
+      const flowId = event.runId;
+      if (!flowId) return;
+      try {
+        const sp = getStateProvider();
+        const prefix = `flow:${flowId}:`;
+        const { keys } = await sp.list(prefix);
+        if (keys.length > 0) {
+          const rc2 = useRuntimeConfig();
+          const ns = rc2?.queue?.state?.namespace || "nq";
+          const nsPrefix = `${ns}:`;
+          await Promise.all(keys.map((k) => {
+            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
+            return sp.delete(keyWithoutNs);
+          }));
+          logger.info(`Cleaned up ${keys.length} state keys after flow completion`, { flowId, keys });
+        }
+      } catch (error) {
+        logger.error("Error cleaning up state after flow completion", { flowId, error });
+      }
+    }));
+    unsubs.push(onType("flow.failed", async (event) => {
+      const flowId = event.runId;
+      if (!flowId) return;
+      try {
+        const sp = getStateProvider();
+        const prefix = `flow:${flowId}:`;
+        const { keys } = await sp.list(prefix);
+        if (keys.length > 0) {
+          const rc2 = useRuntimeConfig();
+          const ns = rc2?.queue?.state?.namespace || "nq";
+          const nsPrefix = `${ns}:`;
+          await Promise.all(keys.map((k) => {
+            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
+            return sp.delete(keyWithoutNs);
+          }));
+          logger.info(`Cleaned up ${keys.length} state keys after flow failure`, { flowId, keys });
+        }
+      } catch (error) {
+        logger.error("Error cleaning up state after flow failure", { flowId, error });
+      }
+    }));
+    logger.debug("Plugin initialized with strategy: on-complete");
+  } else if (cleanup.strategy === "immediate") {
+    unsubs.push(onType("step.completed", async (event) => {
+      const flowId = event.runId;
+      if (!flowId) return;
+      try {
+        const sp = getStateProvider();
+        const prefix = `flow:${flowId}:`;
+        const { keys } = await sp.list(prefix);
+        if (keys.length > 0) {
+          const rc2 = useRuntimeConfig();
+          const ns = rc2?.queue?.state?.namespace || "nq";
+          const nsPrefix = `${ns}:`;
+          await Promise.all(keys.map((k) => {
+            const keyWithoutNs = k.startsWith(nsPrefix) ? k.substring(nsPrefix.length) : k;
+            return sp.delete(keyWithoutNs);
+          }));
+          logger.info(`Cleaned up ${keys.length} state keys after step completion`, { flowId, keys });
+        }
+      } catch (error) {
+        logger.error("Error cleaning up state after step", { flowId, error });
+      }
+    }));
+    logger.debug("Plugin initialized with strategy: immediate");
+  }
+  return {
+    hooks: {
+      close: async () => {
+        for (const u of unsubs) {
+          try {
+            u();
+          } catch {
+          }
+        }
+        unsubs.length = 0;
+      }
+    }
+  };
+});

package/dist/runtime/server/plugins/worker-management.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/plugins/worker-management.js

@@ -0,0 +1,33 @@
+import { defineNitroPlugin, $useWorkerHandlers, $useQueueRegistry } from "#imports";
+import { registerTsWorker, closeAllWorkers } from "../worker/adapter.js";
+export default defineNitroPlugin(async (nitroApp) => {
+  nitroApp.hooks.hook("close", async () => {
+    await closeAllWorkers();
+  });
+  try {
+    const handlers = $useWorkerHandlers();
+    const registry = $useQueueRegistry() || { workers: [] };
+    for (const entry of handlers) {
+      const { queue, id, handler } = entry;
+      const w = registry.workers.find((rw) => rw?.id === id || rw?.queue?.name === queue && rw?.absPath === entry.absPath);
+      let jobName;
+      if (w?.flow?.step) {
+        jobName = Array.isArray(w.flow.step) ? w.flow.step[0] : w.flow.step;
+      } else {
+        jobName = id.includes("/") ? id.split("/").pop() : id;
+      }
+      if (typeof handler === "function") {
+        const cfg = w && w.worker || {};
+        const opts = {};
+        if (typeof cfg.concurrency === "number") opts.concurrency = cfg.concurrency;
+        if (typeof cfg.lockDurationMs === "number") opts.lockDuration = cfg.lockDurationMs;
+        if (typeof cfg.maxStalledCount === "number") opts.maxStalledCount = cfg.maxStalledCount;
+        if (typeof cfg.drainDelayMs === "number") opts.drainDelay = cfg.drainDelayMs;
+        if (typeof cfg.autorun === "boolean") opts.autorun = cfg.autorun;
+        if (w?.queue?.prefix) opts.prefix = w.queue.prefix;
+        await registerTsWorker(queue, jobName, handler, opts);
+      }
+    }
+  } catch {
+  }
+});

package/dist/runtime/server/queue/adapters/bullmq.d.ts

@@ -0,0 +1,17 @@
+import type { QueueProvider, JobInput, Job, JobsQuery, ScheduleOptions, QueueEvent, JobCounts } from '../types.js';
+export declare class BullMQProvider implements QueueProvider {
+    private queues;
+    init(): Promise<void>;
+    private ensureQueue;
+    enqueue(queueName: string, job: JobInput): Promise<string>;
+    schedule(queueName: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
+    getJob(queueName: string, id: string): Promise<Job | null>;
+    getJobs(queueName: string, _q?: JobsQuery): Promise<Job[]>;
+    on(queueName: string, event: QueueEvent, cb: (p: any) => void): () => void;
+    isPaused(queueName: string): Promise<boolean>;
+    getJobCounts(queueName: string): Promise<JobCounts>;
+    pause(queueName: string): Promise<void>;
+    resume(queueName: string): Promise<void>;
+    close(): Promise<void>;
+    private toJob;
+}

package/dist/runtime/server/queue/adapters/bullmq.js

@@ -0,0 +1,164 @@
+import { Queue, QueueEvents } from "bullmq";
+import defu from "defu";
+import { useServerLogger, useRuntimeConfig, $useQueueRegistry, useEventManager } from "#imports";
+const logger = useServerLogger("bullmq-adapter");
+export class BullMQProvider {
+  queues = /* @__PURE__ */ new Map();
+  async init() {
+  }
+  ensureQueue(name) {
+    let cached = this.queues.get(name);
+    if (cached) return cached;
+    const { publishBus } = useEventManager();
+    const rc = useRuntimeConfig();
+    const connection = rc.queue?.queue?.redis;
+    let queueDefaults = void 0;
+    let prefix;
+    let limiter = void 0;
+    try {
+      const registry = $useQueueRegistry();
+      if (registry && Array.isArray(registry.workers)) {
+        const w = registry.workers.find((w2) => w2?.queue?.name === name);
+        if (w?.queue) {
+          queueDefaults = w.queue.defaultJobOptions;
+          prefix = w.queue.prefix;
+          limiter = w.queue.limiter;
+        }
+      }
+    } catch {
+    }
+    const queueOpts = { connection, prefix, defaultJobOptions: queueDefaults };
+    if (limiter) {
+      queueOpts.limiter = {
+        max: limiter.max,
+        duration: limiter.duration,
+        groupKey: limiter.groupKey
+      };
+    }
+    const queue = new Queue(name, queueOpts);
+    const events = new QueueEvents(name, { connection, prefix });
+    events.setMaxListeners(50);
+    cached = { queue, events, wired: false, defaults: queueDefaults };
+    this.queues.set(name, cached);
+    const forward = async (kind, payload) => {
+      const jobId = payload?.jobId || "unknown";
+      let runId = "";
+      try {
+        if (jobId && jobId !== "unknown") {
+          const job = await queue.getJob(jobId);
+          if (job?.data?.flowId) {
+            runId = job.data.flowId;
+          }
+        }
+      } catch {
+      }
+      const rec = {
+        type: `job.${kind}`,
+        runId,
+        data: { ...payload, queue: name, jobId }
+      };
+      await publishBus(rec);
+    };
+    for (const ev of ["waiting", "active", "progress", "completed", "failed", "delayed"]) {
+      events.on(ev, (p) => {
+        void forward(ev, p);
+      });
+    }
+    cached.wired = true;
+    return cached;
+  }
+  async enqueue(queueName, job) {
+    const { queue, defaults } = this.ensureQueue(queueName);
+    const opts = defu(job.opts || {}, defaults || {});
+    const bullJob = await queue.add(job.name, job.data, opts);
+    return bullJob.id;
+  }
+  async schedule(queueName, job, opts) {
+    const { queue, defaults } = this.ensureQueue(queueName);
+    const jobsOpts = defu({ ...job.opts }, defaults || {});
+    if (opts?.delay) jobsOpts.delay = opts.delay;
+    if (opts?.cron) jobsOpts.repeat = { pattern: opts.cron };
+    const bullJob = await queue.add(job.name, job.data, jobsOpts);
+    return bullJob.id;
+  }
+  async getJob(queueName, id) {
+    const { queue } = this.ensureQueue(queueName);
+    const j = await queue.getJob(id);
+    if (!j) return null;
+    return await this.toJob(j);
+  }
+  async getJobs(queueName, _q) {
+    const { queue } = this.ensureQueue(queueName);
+    const states = _q?.state && _q.state.length > 0 ? _q.state : ["waiting", "active", "completed", "failed", "delayed", "paused"];
+    const limit = _q?.limit || 1e3;
+    const jobs = await queue.getJobs(states, 0, limit - 1);
+    return await Promise.all(jobs.map((j) => this.toJob(j)));
+  }
+  on(queueName, event, cb) {
+    const { events } = this.ensureQueue(queueName);
+    const handler = (payload) => cb(payload);
+    events.on(event, handler);
+    return () => {
+      events.off(event, handler);
+    };
+  }
+  async isPaused(queueName) {
+    const { queue } = this.ensureQueue(queueName);
+    return await queue.isPaused();
+  }
+  async getJobCounts(queueName) {
+    const { queue } = this.ensureQueue(queueName);
+    const counts = await queue.getJobCounts("waiting", "active", "completed", "failed", "delayed", "paused");
+    return {
+      active: counts.active || 0,
+      completed: counts.completed || 0,
+      failed: counts.failed || 0,
+      delayed: counts.delayed || 0,
+      waiting: counts.waiting || 0,
+      paused: counts.paused || 0
+    };
+  }
+  async pause(queueName) {
+    const { queue } = this.ensureQueue(queueName);
+    await queue.pause();
+  }
+  async resume(queueName) {
+    const { queue } = this.ensureQueue(queueName);
+    await queue.resume();
+  }
+  async close() {
+    const closePromises = [];
+    for (const [queueName, { queue, events }] of this.queues.entries()) {
+      closePromises.push(
+        queue.close().catch((err) => {
+          if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
+            logger.warn("Error closing queue", { queueName, error: err });
+          }
+        })
+      );
+      closePromises.push(
+        events.close().catch((err) => {
+          if (err.code !== "EPIPE" && !err.message?.includes("Connection is closed")) {
+            logger.warn("Error closing events for queue", { queueName, error: err });
+          }
+        })
+      );
+    }
+    await Promise.allSettled(closePromises);
+    this.queues.clear();
+  }
+  async toJob(j) {
+    const state = await j.getState();
+    return {
+      id: j.id,
+      name: j.name,
+      data: j.data,
+      returnvalue: j.returnvalue,
+      failedReason: j.failedReason,
+      state,
+      timestamp: j.timestamp,
+      processedOn: j.processedOn,
+      finishedOn: j.finishedOn
+    };
+  }
+}

package/dist/runtime/server/queue/queueFactory.d.ts

@@ -0,0 +1,3 @@
+import type { QueueProvider } from './types.js';
+export declare function setQueueProvider(p: QueueProvider): void;
+export declare function getQueueProvider(): QueueProvider;

package/dist/runtime/server/queue/queueFactory.js

@@ -0,0 +1,10 @@
+let currentProvider = null;
+export function setQueueProvider(p) {
+  currentProvider = p;
+}
+export function getQueueProvider() {
+  if (!currentProvider) {
+    throw new Error("[nuxt-queue] QueueProvider not initialized");
+  }
+  return currentProvider;
+}

package/dist/runtime/server/queue/types.d.ts

@@ -0,0 +1,47 @@
+export type JobCounts = {
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+    waiting: number;
+    paused: number;
+};
+export type QueueEvent = 'added' | 'waiting' | 'active' | 'progress' | 'completed' | 'failed' | 'paused' | 'resumed';
+export interface JobInput {
+    name: string;
+    data: any;
+    opts?: Record<string, any>;
+}
+export interface Job {
+    id: string;
+    name: string;
+    data: any;
+    state?: 'waiting' | 'active' | 'completed' | 'failed' | 'delayed' | 'paused';
+    returnvalue?: any;
+    failedReason?: string;
+    timestamp?: number;
+    processedOn?: number;
+    finishedOn?: number;
+}
+export interface JobsQuery {
+    state?: Array<Job['state']>;
+    limit?: number;
+    cursor?: string;
+}
+export interface ScheduleOptions {
+    delay?: number;
+    cron?: string;
+}
+export interface QueueProvider {
+    init(): Promise<void>;
+    enqueue(queue: string, job: JobInput): Promise<string>;
+    schedule(queue: string, job: JobInput, opts?: ScheduleOptions): Promise<string>;
+    getJob(queue: string, id: string): Promise<Job | null>;
+    getJobs(queue: string, q?: JobsQuery): Promise<Job[]>;
+    on(queue: string, event: QueueEvent, cb: (p: any) => void): () => void;
+    getJobCounts?(queue: string): Promise<Record<string, number>>;
+    isPaused?(queue: string): Promise<boolean>;
+    pause(queue: string): Promise<void>;
+    resume(queue: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/runtime/server/state/adapters/redis.d.ts

@@ -0,0 +1,2 @@
+import type { StateProvider } from '../types.js';
+export declare function createRedisStateProvider(namespace?: string): StateProvider;

package/dist/runtime/server/state/adapters/redis.js

@@ -0,0 +1,42 @@
+import { useStorage, useRuntimeConfig } from "#imports";
+function nsKey(ns, key) {
+  if (!key) return ns;
+  return key.startsWith(ns + ":") ? key : `${ns}:${key}`;
+}
+export function createRedisStateProvider(namespace) {
+  const storage = useStorage("redis");
+  const ns = namespace || useRuntimeConfig()?.queue?.state?.namespace || "nq";
+  return {
+    async get(key) {
+      return storage.getItem(nsKey(ns, key));
+    },
+    async set(key, value, opts) {
+      await storage.setItem(nsKey(ns, key), value, { ttl: opts?.ttl });
+    },
+    async delete(key) {
+      await storage.removeItem(nsKey(ns, key));
+    },
+    async list(prefix, opts) {
+      const base = nsKey(ns, prefix);
+      const keys = await storage.getKeys(base);
+      const filtered = keys.filter((k) => k.startsWith(base)).slice(0, opts?.limit || keys.length);
+      return { keys: filtered };
+    },
+    async patch(key, updater, opts) {
+      const retries = Math.max(0, opts?.retries ?? 3);
+      const k = nsKey(ns, key);
+      let lastErr;
+      for (let i = 0; i <= retries; i++) {
+        try {
+          const prev = await storage.getItem(k);
+          const next = updater(prev);
+          await storage.setItem(k, next);
+          return next;
+        } catch (err) {
+          lastErr = err;
+        }
+      }
+      throw lastErr || new Error("patch failed");
+    }
+  };
+}

package/dist/runtime/server/state/stateFactory.d.ts

@@ -0,0 +1,3 @@
+import type { StateProvider } from './types.js';
+export declare function getStateProvider(): StateProvider;
+export declare function setStateProvider(p: StateProvider): void;

package/dist/runtime/server/state/stateFactory.js

@@ -0,0 +1,17 @@
+import { useRuntimeConfig } from "#imports";
+import { createRedisStateProvider } from "./adapters/redis.js";
+let currentStateProvider = null;
+export function getStateProvider() {
+  if (currentStateProvider) return currentStateProvider;
+  const rc = useRuntimeConfig();
+  const adapter = rc?.queue?.state?.adapter || "redis";
+  const ns = rc?.queue?.state?.namespace || "nq";
+  if (adapter === "redis") {
+    currentStateProvider = createRedisStateProvider(ns);
+    return currentStateProvider;
+  }
+  throw new Error(`[nuxt-queue] Unsupported StateProvider: ${adapter}`);
+}
+export function setStateProvider(p) {
+  currentStateProvider = p;
+}

package/dist/runtime/server/state/types.d.ts

@@ -0,0 +1,23 @@
+export interface StateProvider {
+    get<T = any>(key: string): Promise<T | null>;
+    set<T = any>(key: string, value: T, opts?: {
+        ttl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix: string, opts?: {
+        limit?: number;
+    }): Promise<{
+        keys: string[];
+    }>;
+    patch<T = any>(key: string, updater: (prev: T | null) => T, opts?: {
+        retries?: number;
+    }): Promise<T>;
+}
+export interface StorageLike {
+    getItem<T = any>(key: string): Promise<T | null>;
+    setItem<T = any>(key: string, value: T, opts?: {
+        ttl?: number;
+    }): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    getKeys(base?: string): Promise<string[]>;
+}

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "../../../playground/.nuxt/tsconfig.server.json",
+}