nvent 0.5.15 → 1.0.0-alpha.2

package/dist/runtime/nitro/utils/awaitPatterns/index.js

@@ -1,55 +0,0 @@
-import { useNventLogger } from "#imports";
-import { registerWebhookAwait, resolveWebhookAwait } from "./webhook.js";
-import { registerEventAwait, resolveEventAwait } from "./event.js";
-import { registerScheduleAwait, resolveScheduleAwait } from "./schedule.js";
-import { registerTimeAwait, resolveTimeAwait } from "./time.js";
-export async function registerAwaitPattern(runId, stepName, flowName, config, position = "after") {
-  const logger = useNventLogger("await-patterns");
-  logger.info(`Registering await pattern: ${config.type}`, {
-    runId,
-    stepName,
-    type: config.type
-  });
-  switch (config.type) {
-    case "webhook":
-      return await registerWebhookAwait(runId, stepName, flowName, config, position);
-    case "event":
-      return await registerEventAwait(runId, stepName, flowName, config, position);
-    case "schedule":
-      return await registerScheduleAwait(runId, stepName, flowName, config, position);
-    case "time":
-      return await registerTimeAwait(runId, stepName, flowName, config, position);
-    default:
-      throw new Error(`Unknown await pattern type: ${config.type}`);
-  }
-}
-export async function resolveAwaitPattern(type, runId, stepName, flowName, position, data) {
-  const logger = useNventLogger("await-patterns");
-  logger.info(`Resolving await pattern: ${type}`, {
-    runId,
-    stepName,
-    type
-  });
-  switch (type) {
-    case "webhook":
-      return await resolveWebhookAwait(runId, stepName, data);
-    case "event":
-      return await resolveEventAwait(runId, stepName, data);
-    case "schedule":
-      return await resolveScheduleAwait(runId, stepName, data);
-    case "time":
-      return await resolveTimeAwait(runId, stepName, flowName, position, data);
-    default:
-      throw new Error(`Unknown await pattern type: ${type}`);
-  }
-}
-export {
-  registerWebhookAwait,
-  resolveWebhookAwait,
-  registerEventAwait,
-  resolveEventAwait,
-  registerScheduleAwait,
-  resolveScheduleAwait,
-  registerTimeAwait,
-  resolveTimeAwait
-};

package/dist/runtime/nitro/utils/awaitPatterns/schedule.d.ts

@@ -1,16 +0,0 @@
-import type { AwaitConfig } from '../../../../registry/types.js';
-/**
- * Await Pattern: Schedule
- *
- * Waits until next cron schedule occurrence
- * Useful for batch processing, daily reports, scheduled operations
- */
-export declare function registerScheduleAwait(runId: string, stepName: string, flowName: string, config: AwaitConfig, position?: 'before' | 'after'): Promise<{
-    cron: string;
-    nextOccurrence: number;
-    timeUntilNext: number;
-}>;
-/**
- * Resolve schedule await when cron time is reached
- */
-export declare function resolveScheduleAwait(runId: string, stepName: string, flowName: string, position: 'before' | 'after', scheduleData: any): Promise<void>;

package/dist/runtime/nitro/utils/awaitPatterns/schedule.js

@@ -1,83 +0,0 @@
-import { useNventLogger, useScheduler } from "#imports";
-import { getEventBus } from "../../../events/eventBus.js";
-import { CronJob } from "cron";
-export async function registerScheduleAwait(runId, stepName, flowName, config, position = "after") {
-  const logger = useNventLogger("await-schedule");
-  const eventBus = getEventBus();
-  const scheduler = useScheduler();
-  if (!config.cron) {
-    throw new Error("Schedule await requires cron expression configuration");
-  }
-  logger.info(`Registering schedule await: ${config.cron}`, { runId, stepName });
-  const cronJob = new CronJob(config.cron, () => {
-  }, null, false, config.timezone || "UTC");
-  const nextDate = cronJob.nextDate();
-  const nextOccurrence = nextDate ? nextDate.toMillis() : Date.now() + 6e4;
-  const timeUntilNext = nextOccurrence - Date.now();
-  const jobId = `await-schedule-${runId}-${stepName}-${position}`;
-  await scheduler.schedule({
-    id: jobId,
-    name: `Schedule Await: ${flowName} - ${stepName}`,
-    type: "one-time",
-    executeAt: nextOccurrence,
-    handler: async () => {
-      await resolveScheduleAwait(runId, stepName, flowName, position, { scheduledAt: nextOccurrence });
-    },
-    metadata: {
-      component: "await-pattern",
-      awaitType: "schedule",
-      runId,
-      stepName,
-      flowName,
-      position,
-      cron: config.cron,
-      timezone: config.timezone
-    }
-  });
-  eventBus.publish({
-    type: "await.registered",
-    flowName,
-    runId,
-    stepName,
-    awaitType: "schedule",
-    position,
-    config,
-    data: {
-      position,
-      // Store position in data for database persistence
-      cron: config.cron,
-      nextOccurrence,
-      timeUntilNext,
-      registeredAt: Date.now()
-    }
-  });
-  logger.debug(`Schedule await registered: ${config.cron} (next: ${new Date(nextOccurrence).toISOString()})`, {
-    runId,
-    stepName
-  });
-  return {
-    cron: config.cron,
-    nextOccurrence,
-    timeUntilNext
-  };
-}
-export async function resolveScheduleAwait(runId, stepName, flowName, position, scheduleData) {
-  const logger = useNventLogger("await-schedule");
-  const eventBus = getEventBus();
-  logger.info(`Resolving schedule await`, { runId, stepName });
-  const scheduledAt = scheduleData?.scheduledAt || Date.now();
-  eventBus.publish({
-    type: "await.resolved",
-    flowName,
-    runId,
-    stepName,
-    position,
-    triggerData: { scheduledAt },
-    data: {
-      position,
-      // Store position in data for database persistence
-      resolvedAt: Date.now()
-    }
-  });
-  logger.debug(`Schedule await resolved`, { runId, stepName });
-}

package/dist/runtime/nitro/utils/awaitPatterns/time.d.ts

@@ -1,15 +0,0 @@
-import type { AwaitConfig } from '../../../../registry/types.js';
-/**
- * Await Pattern: Time
- *
- * Simple delay/timeout - waits for a specific duration
- * Useful for cooldown periods, rate limiting, delayed notifications
- */
-export declare function registerTimeAwait(runId: string, stepName: string, flowName: string, config: AwaitConfig, position?: 'before' | 'after'): Promise<{
-    delay: number;
-    resolveAt: number;
-}>;
-/**
- * Resolve time await when delay completes
- */
-export declare function resolveTimeAwait(runId: string, stepName: string, flowName: string, position: 'before' | 'after', _timeData: any): Promise<void>;

package/dist/runtime/nitro/utils/awaitPatterns/time.js

@@ -1,71 +0,0 @@
-import { useNventLogger, useScheduler } from "#imports";
-import { getEventBus } from "../../../events/eventBus.js";
-export async function registerTimeAwait(runId, stepName, flowName, config, position = "after") {
-  const logger = useNventLogger("await-time");
-  const eventBus = getEventBus();
-  const scheduler = useScheduler();
-  if (!config.delay) {
-    throw new Error("Time await requires delay configuration (in milliseconds)");
-  }
-  logger.info(`Registering time await: ${config.delay}ms`, { runId, stepName });
-  const resolveAt = Date.now() + config.delay;
-  const jobId = `await-time-${runId}-${stepName}-${position}`;
-  await scheduler.schedule({
-    id: jobId,
-    name: `Time Await: ${flowName} - ${stepName}`,
-    type: "one-time",
-    executeAt: resolveAt,
-    handler: async () => {
-      await resolveTimeAwait(runId, stepName, flowName, position, { delayCompleted: true });
-    },
-    metadata: {
-      component: "await-pattern",
-      awaitType: "time",
-      runId,
-      stepName,
-      flowName,
-      position,
-      delay: config.delay
-    }
-  });
-  eventBus.publish({
-    type: "await.registered",
-    flowName,
-    runId,
-    stepName,
-    awaitType: "time",
-    position,
-    config,
-    data: {
-      position,
-      // Store position in data for database persistence
-      delay: config.delay,
-      resolveAt,
-      registeredAt: Date.now()
-    }
-  });
-  logger.debug(`Time await registered: ${config.delay}ms`, { runId, stepName });
-  return {
-    delay: config.delay,
-    resolveAt
-  };
-}
-export async function resolveTimeAwait(runId, stepName, flowName, position, _timeData) {
-  const logger = useNventLogger("await-time");
-  const eventBus = getEventBus();
-  logger.info(`Resolving time await`, { runId, stepName });
-  eventBus.publish({
-    type: "await.resolved",
-    flowName,
-    runId,
-    stepName,
-    position,
-    triggerData: {},
-    data: {
-      position,
-      // Store position in data for database persistence
-      resolvedAt: Date.now()
-    }
-  });
-  logger.debug(`Time await resolved`, { runId, stepName });
-}

package/dist/runtime/nitro/utils/awaitPatterns/webhook.d.ts

@@ -1,15 +0,0 @@
-import type { AwaitConfig } from '../../../../registry/types.js';
-/**
- * Await Pattern: Webhook
- *
- * Creates a dynamic webhook endpoint that resolves when called
- * Useful for human approval flows, external integrations
- */
-export declare function registerWebhookAwait(runId: string, stepName: string, flowName: string, config: AwaitConfig, position?: 'before' | 'after'): Promise<{
-    webhookUrl: string;
-    timeout: number | undefined;
-}>;
-/**
- * Resolve webhook await when webhook is called
- */
-export declare function resolveWebhookAwait(runId: string, stepName: string, flowName: string, position: 'before' | 'after', webhookData: any): Promise<void>;

package/dist/runtime/nitro/utils/awaitPatterns/webhook.js

@@ -1,128 +0,0 @@
-import { useNventLogger, useRuntimeConfig, useScheduler } from "#imports";
-import { getEventBus } from "../../../events/eventBus.js";
-export async function registerWebhookAwait(runId, stepName, flowName, config, position = "after") {
-  const logger = useNventLogger("await-webhook");
-  const eventBus = getEventBus();
-  const runtimeConfig = useRuntimeConfig();
-  const path = `/${flowName}/${runId}/${stepName}`;
-  let baseUrl = runtimeConfig.nvent?.webhooks?.baseUrl;
-  if (!baseUrl) {
-    const nitroApp = runtimeConfig.nitro?.app;
-    if (nitroApp?.baseURL) {
-      baseUrl = `${nitroApp.baseURL}`;
-    }
-    if (!baseUrl) {
-      baseUrl = process.env.NITRO_URL || process.env.URL || (process.env.NODE_ENV === "development" ? "http://localhost:3000" : void 0);
-    }
-  }
-  if (!baseUrl) {
-    logger.warn("No baseUrl configured for webhooks. Set NUXT_PUBLIC_SITE_URL or nvent.webhooks.baseUrl");
-    baseUrl = "http://localhost:3000";
-  }
-  const webhookPath = `/api/_webhook/await${path}`;
-  const fullWebhookUrl = `${baseUrl.replace(/\/$/, "")}${webhookPath}`;
-  logger.info(`Registering webhook await: ${fullWebhookUrl}`, { runId, stepName });
-  const { useAwaitDefaults } = await import("../useAwait.js");
-  const { webhookTimeout: defaultTimeout, timeoutAction: defaultTimeoutAction } = useAwaitDefaults();
-  const timeoutMs = config.timeout && config.timeout > 0 ? config.timeout : defaultTimeout;
-  eventBus.publish({
-    type: "await.registered",
-    flowName,
-    runId,
-    stepName,
-    awaitType: "webhook",
-    position,
-    config,
-    data: {
-      position,
-      // Store position in data for database persistence
-      path,
-      method: config.method || "POST",
-      timeout: timeoutMs,
-      // Store resolved timeout (with default)
-      registeredAt: Date.now(),
-      webhookUrl: fullWebhookUrl,
-      timeoutAction: config.timeoutAction || defaultTimeoutAction
-    }
-  });
-  const scheduler = useScheduler();
-  const timeoutAt = Date.now() + timeoutMs;
-  const jobId = `await-webhook-timeout-${runId}-${stepName}-${position}`;
-  await scheduler.schedule({
-    id: jobId,
-    name: `Webhook Timeout: ${flowName} - ${stepName}`,
-    type: "one-time",
-    executeAt: timeoutAt,
-    handler: async () => {
-      logger.warn("Webhook await timeout", {
-        runId,
-        stepName,
-        flowName,
-        timeout: timeoutMs,
-        timeoutAction: config.timeoutAction || "fail"
-      });
-      eventBus.publish({
-        type: "await.timeout",
-        flowName,
-        runId,
-        stepName,
-        position,
-        awaitType: "webhook",
-        timeoutAction: config.timeoutAction || "fail",
-        data: {
-          timeout: timeoutMs,
-          registeredAt: Date.now() - timeoutMs,
-          timedOutAt: Date.now()
-        }
-      });
-    },
-    metadata: {
-      component: "await-pattern",
-      awaitType: "webhook",
-      runId,
-      stepName,
-      flowName,
-      position,
-      timeout: timeoutMs
-    }
-  });
-  logger.debug(`Webhook timeout scheduled`, {
-    runId,
-    stepName,
-    timeout: timeoutMs,
-    timeoutAction: config.timeoutAction,
-    isDefault: !config.timeout || config.timeout <= 0
-  });
-  logger.debug(`Webhook await registered: ${fullWebhookUrl}`, { runId, stepName });
-  return {
-    webhookUrl: fullWebhookUrl,
-    timeout: config.timeout
-  };
-}
-export async function resolveWebhookAwait(runId, stepName, flowName, position, webhookData) {
-  const logger = useNventLogger("await-webhook");
-  const eventBus = getEventBus();
-  const scheduler = useScheduler();
-  logger.info(`Resolving webhook await`, { runId, stepName });
-  const jobId = `await-webhook-timeout-${runId}-${stepName}-${position}`;
-  try {
-    await scheduler.unschedule(jobId);
-    logger.debug("Unscheduled webhook timeout job", { runId, stepName, jobId });
-  } catch {
-    logger.debug("Could not unschedule timeout job (may not exist)", { runId, stepName, jobId });
-  }
-  eventBus.publish({
-    type: "await.resolved",
-    flowName,
-    runId,
-    stepName,
-    position,
-    triggerData: webhookData,
-    data: {
-      position,
-      // Store position in data for database persistence
-      resolvedAt: Date.now()
-    }
-  });
-  logger.debug(`Webhook await resolved`, { runId, stepName });
-}