next-workflow-builder 0.3.0

package/dist/condition-SFT7Y5YJ.js

@@ -0,0 +1,29 @@
+import "./chunk-7MUXUHEL.js";
+import "./chunk-D44JFQYX.js";
+import "./chunk-P3DTV3QS.js";
+import "./chunk-5YYA34YV.js";
+import "./chunk-OQHML4II.js";
+import "./chunk-DJ7ANVJ3.js";
+import "./chunk-BNYDOC3I.js";
+import "./chunk-Z3BJJYHM.js";
+import "./chunk-O3I2INCD.js";
+import {
+  withStepLogging
+} from "./chunk-3MSAF2TH.js";
+
+// src/plugins/condition/condition.ts
+import "server-only";
+function evaluateCondition(input) {
+  return { condition: input.condition };
+}
+async function conditionStep(input) {
+  "use step";
+  return withStepLogging(
+    input,
+    () => Promise.resolve(evaluateCondition(input))
+  );
+}
+conditionStep.maxRetries = 0;
+export {
+  conditionStep
+};

package/dist/database-query-GRWP3S3M.js

@@ -0,0 +1,99 @@
+import {
+  fetchCredentials
+} from "./chunk-DJ7ANVJ3.js";
+import "./chunk-BNYDOC3I.js";
+import "./chunk-Z3BJJYHM.js";
+import {
+  withStepLogging
+} from "./chunk-3MSAF2TH.js";
+
+// src/plugins/database-query/database-query.ts
+import "server-only";
+import { sql } from "drizzle-orm";
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+function validateInput(input) {
+  const queryString = input.dbQuery || input.query;
+  if (!queryString || queryString.trim() === "") {
+    return "SQL query is required";
+  }
+  return null;
+}
+function createDatabaseClient(databaseUrl) {
+  return postgres(databaseUrl, {
+    max: 1,
+    connect_timeout: 10,
+    idle_timeout: 20
+  });
+}
+async function executeQuery(client, queryString) {
+  const db = drizzle(client);
+  return await db.execute(sql.raw(queryString));
+}
+function getDatabaseErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return "Unknown database error";
+  }
+  const errorMessage = error.message;
+  if (errorMessage.includes("ECONNREFUSED")) {
+    return "Connection refused. Please check your database URL and ensure the database is running.";
+  }
+  if (errorMessage.includes("ENOTFOUND")) {
+    return "Database host not found. Please check your database URL.";
+  }
+  if (errorMessage.includes("authentication failed")) {
+    return "Authentication failed. Please check your database credentials.";
+  }
+  if (errorMessage.includes("does not exist")) {
+    return `Database error: ${errorMessage}`;
+  }
+  return errorMessage;
+}
+async function cleanupClient(client) {
+  if (client) {
+    try {
+      await client.end();
+    } catch {
+    }
+  }
+}
+async function databaseQuery(input) {
+  const validationError = validateInput(input);
+  if (validationError) {
+    return { success: false, error: validationError };
+  }
+  const credentials = input.integrationId ? await fetchCredentials(input.integrationId) : {};
+  const databaseUrl = credentials.DATABASE_URL;
+  if (!databaseUrl) {
+    return {
+      success: false,
+      error: "DATABASE_URL is not configured. Please add it in Project Integrations."
+    };
+  }
+  const queryString = input.dbQuery || input.query;
+  let client = null;
+  try {
+    client = createDatabaseClient(databaseUrl);
+    const result = await executeQuery(client, queryString);
+    await client.end();
+    return {
+      success: true,
+      rows: result,
+      count: Array.isArray(result) ? result.length : 0
+    };
+  } catch (error) {
+    await cleanupClient(client);
+    return {
+      success: false,
+      error: `Database query failed: ${getDatabaseErrorMessage(error)}`
+    };
+  }
+}
+async function databaseQueryStep(input) {
+  "use step";
+  return withStepLogging(input, () => databaseQuery(input));
+}
+databaseQueryStep.maxRetries = 0;
+export {
+  databaseQueryStep
+};

package/dist/http-request-2HVCXQHK.js

@@ -0,0 +1,76 @@
+import {
+  getErrorMessage
+} from "./chunk-O3I2INCD.js";
+import {
+  withStepLogging
+} from "./chunk-3MSAF2TH.js";
+
+// src/plugins/http-request/http-request.ts
+import "server-only";
+function parseHeaders(httpHeaders) {
+  if (!httpHeaders) {
+    return {};
+  }
+  try {
+    return JSON.parse(httpHeaders);
+  } catch {
+    return {};
+  }
+}
+function parseBody(httpMethod, httpBody) {
+  if (httpMethod === "GET" || !httpBody) {
+    return;
+  }
+  try {
+    const parsedBody = JSON.parse(httpBody);
+    return Object.keys(parsedBody).length > 0 ? JSON.stringify(parsedBody) : void 0;
+  } catch {
+    const trimmed = httpBody.trim();
+    return trimmed && trimmed !== "{}" ? httpBody : void 0;
+  }
+}
+function parseResponse(response) {
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+async function httpRequest(input) {
+  if (!input.endpoint) {
+    return {
+      success: false,
+      error: "HTTP request failed: URL is required"
+    };
+  }
+  try {
+    const response = await fetch(input.endpoint, {
+      method: input.httpMethod,
+      headers: parseHeaders(input.httpHeaders),
+      body: parseBody(input.httpMethod, input.httpBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      return {
+        success: false,
+        error: `HTTP request failed with status ${response.status}: ${errorText}`,
+        status: response.status
+      };
+    }
+    const data = await parseResponse(response);
+    return { success: true, data, status: response.status };
+  } catch (error) {
+    return {
+      success: false,
+      error: `HTTP request failed: ${getErrorMessage(error)}`
+    };
+  }
+}
+async function httpRequestStep(input) {
+  "use step";
+  return withStepLogging(input, () => httpRequest(input));
+}
+httpRequestStep.maxRetries = 0;
+export {
+  httpRequestStep
+};

package/dist/next/index.d.ts

@@ -0,0 +1,42 @@
+import { NextConfig } from 'next';
+import { z } from 'zod';
+
+declare const NextWorkflowBuilderConfigSchema: z.ZodObject<{
+    /** Enable debug logging. */
+    debug: z.ZodOptional<z.ZodBoolean>;
+    /** Set Better Auth options (must be JSON-serializable). */
+    authOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+
+/**
+ * Configuration options for the Next Workflow Builder plugin.
+ * Infer the type from the schema
+ */
+type NextWorkflowBuilderConfig = z.infer<typeof NextWorkflowBuilderConfigSchema>;
+/**
+ * A function that wraps a Next.js config with Workflow Builder functionality.
+ */
+type WithNextWorkflowBuilder = (nextConfig?: NextConfig) => NextConfig;
+
+/**
+ * Next.js plugin for Workflow Builder.
+ *
+ * @example
+ * ```js
+ * // next.config.ts
+ * import nextWorkflowBuilder from 'next-workflow-builder'
+ *
+ * // Set up NextWorkflowBuilder with its configuration
+ * const withNextWorkflowBuilder = nextWorkflowBuilder({
+ *   // ... Add NextWorkflowBuilder-specific options here
+ * })
+ *
+ * // Export the final Next.js config with NextWorkflowBuilder included
+ * export default withNextWorkflowBuilder({
+ *   // ... Add regular Next.js options here
+ * })
+ * ```
+ */
+declare const nextWorkflowBuilder: (config?: NextWorkflowBuilderConfig) => WithNextWorkflowBuilder;
+
+export { type NextWorkflowBuilderConfig, type WithNextWorkflowBuilder, nextWorkflowBuilder as default };

package/dist/next/index.js

@@ -0,0 +1,66 @@
+import {
+  discoverPlugins
+} from "../chunk-D44JFQYX.js";
+import "../chunk-OQHML4II.js";
+import "../chunk-Z3BJJYHM.js";
+
+// src/next/index.ts
+import { join } from "path";
+import { z as z2 } from "zod";
+
+// src/next/schema.ts
+import { z } from "zod";
+var NextWorkflowBuilderConfigSchema = z.strictObject({
+  /** Enable debug logging. */
+  debug: z.boolean().optional(),
+  /** Set Better Auth options (must be JSON-serializable). */
+  authOptions: z.record(z.string(), z.unknown()).optional()
+});
+
+// src/next/index.ts
+var VIRTUAL_PLUGINS_MODULE = "virtual:workflow-builder-plugins";
+var VIRTUAL_STEP_REGISTRY_MODULE = "virtual:workflow-builder-step-registry";
+var nextWorkflowBuilder = (config = {}) => {
+  const { error, data: loaderOptions } = NextWorkflowBuilderConfigSchema.safeParse(config);
+  if (error) {
+    console.error("Error validating NextWorkflowBuilderConfig");
+    throw z2.prettifyError(error);
+  }
+  if (loaderOptions.authOptions) {
+    process.env.__NWB_AUTH_OPTIONS = JSON.stringify(loaderOptions.authOptions);
+  }
+  discoverPlugins();
+  return function withNextWorkflowBuilder(nextConfig = {}) {
+    const consumerPluginsRelative = "./plugins/index.ts";
+    const consumerPluginsAbsolute = join(process.cwd(), "plugins", "index.ts");
+    const consumerStepRegistryRelative = "./lib/step-registry.ts";
+    const consumerStepRegistryAbsolute = join(process.cwd(), "lib", "step-registry.ts");
+    return {
+      ...nextConfig,
+      // Turbopack alias (used by `next dev` in Next.js 15+)
+      turbopack: {
+        ...nextConfig.turbopack,
+        resolveAlias: {
+          ...nextConfig.turbopack?.resolveAlias,
+          [VIRTUAL_PLUGINS_MODULE]: consumerPluginsRelative,
+          [VIRTUAL_STEP_REGISTRY_MODULE]: consumerStepRegistryRelative
+        }
+      },
+      // Webpack alias (used by `next build`)
+      webpack: (webpackConfig, options) => {
+        webpackConfig.resolve = webpackConfig.resolve || {};
+        webpackConfig.resolve.alias = webpackConfig.resolve.alias || {};
+        webpackConfig.resolve.alias[VIRTUAL_PLUGINS_MODULE] = consumerPluginsAbsolute;
+        webpackConfig.resolve.alias[VIRTUAL_STEP_REGISTRY_MODULE] = consumerStepRegistryAbsolute;
+        if (typeof nextConfig.webpack === "function") {
+          return nextConfig.webpack(webpackConfig, options);
+        }
+        return webpackConfig;
+      }
+    };
+  };
+};
+var next_default = nextWorkflowBuilder;
+export {
+  next_default as default
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,113 @@
+import { I as IntegrationType, A as ActionWithFullId, a as ActionConfigField, b as ActionConfigFieldBase, c as IntegrationPlugin, S as SerializableOutputDisplayConfig, d as ActionConfigFieldGroup } from '../types-BACZx2Ft.js';
+export { P as PluginAction } from '../types-BACZx2Ft.js';
+
+/**
+ * Register codegen templates (called from consumer's auto-generated codegen-registry.ts)
+ */
+declare function registerCodegenTemplates(templates: Record<string, string>): void;
+/**
+ * Get a codegen template for an action
+ */
+declare function getCodegenTemplate(actionId: string): string | undefined;
+/**
+ * Register output display configs (called from consumer's auto-generated output-display-configs.ts)
+ */
+declare function registerOutputDisplayConfigs(configs: Record<string, SerializableOutputDisplayConfig>): void;
+/**
+ * Get the output display config for an action
+ */
+declare function getOutputDisplayConfig(actionId: string): SerializableOutputDisplayConfig | undefined;
+/**
+ * Compute full action ID from integration type and action slug
+ */
+declare function computeActionId(integrationType: IntegrationType, actionSlug: string): string;
+/**
+ * Parse a full action ID into integration type and action slug
+ */
+declare function parseActionId(actionId: string | undefined | null): {
+    integration: string;
+    slug: string;
+} | null;
+/**
+ * Register an integration plugin
+ */
+declare function registerIntegration(plugin: IntegrationPlugin): void;
+/**
+ * Get an integration plugin
+ */
+declare function getIntegration(type: IntegrationType): IntegrationPlugin | undefined;
+/**
+ * Get all registered integrations
+ */
+declare function getAllIntegrations(): IntegrationPlugin[];
+/**
+ * Get all integration types
+ */
+declare function getIntegrationTypes(): IntegrationType[];
+/**
+ * Get all actions across all integrations with full IDs
+ */
+declare function getAllActions(): ActionWithFullId[];
+/**
+ * Get actions by category
+ */
+declare function getActionsByCategory(): Record<string, ActionWithFullId[]>;
+/**
+ * Find an action by full ID (e.g., "resend/send-email")
+ * Also supports legacy IDs (e.g., "Send Email") for backward compatibility
+ */
+declare function findActionById(actionId: string | undefined | null): ActionWithFullId | undefined;
+/**
+ * Get integration labels map
+ */
+declare function getIntegrationLabels(): Record<IntegrationType, string>;
+/**
+ * Get integration descriptions map
+ */
+declare function getIntegrationDescriptions(): Record<IntegrationType, string>;
+/**
+ * Get sorted integration types for dropdowns
+ */
+declare function getSortedIntegrationTypes(): IntegrationType[];
+/**
+ * Get all NPM dependencies across all integrations
+ */
+declare function getAllDependencies(): Record<string, string>;
+/**
+ * Get NPM dependencies for specific action IDs
+ */
+declare function getDependenciesForActions(actionIds: string[]): Record<string, string>;
+/**
+ * Get environment variables for a single plugin (from formFields)
+ */
+declare function getPluginEnvVars(plugin: IntegrationPlugin): Array<{
+    name: string;
+    description: string;
+}>;
+/**
+ * Get all environment variables across all integrations
+ */
+declare function getAllEnvVars(): Array<{
+    name: string;
+    description: string;
+}>;
+/**
+ * Get credential mapping for a plugin (auto-generated from formFields)
+ */
+declare function getCredentialMapping(plugin: IntegrationPlugin, config: Record<string, unknown>): Record<string, string>;
+/**
+ * Type guard to check if a field is a group
+ */
+declare function isFieldGroup(field: ActionConfigField): field is ActionConfigFieldGroup;
+/**
+ * Flatten config fields, extracting fields from groups
+ * Useful for validation and AI prompt generation
+ */
+declare function flattenConfigFields(fields: ActionConfigField[]): ActionConfigFieldBase[];
+/**
+ * Generate AI prompt section for all available actions
+ * This dynamically builds the action types documentation for the AI
+ */
+declare function generateAIActionPrompts(): string;
+
+export { ActionConfigField, ActionConfigFieldBase, ActionConfigFieldGroup, ActionWithFullId, IntegrationPlugin, computeActionId, findActionById, flattenConfigFields, generateAIActionPrompts, getActionsByCategory, getAllActions, getAllDependencies, getAllEnvVars, getAllIntegrations, getCodegenTemplate, getCredentialMapping, getDependenciesForActions, getIntegration, getIntegrationDescriptions, getIntegrationLabels, getIntegrationTypes, getOutputDisplayConfig, getPluginEnvVars, getSortedIntegrationTypes, isFieldGroup, parseActionId, registerCodegenTemplates, registerIntegration, registerOutputDisplayConfigs };

package/dist/plugins/index.js

@@ -0,0 +1,52 @@
+import {
+  computeActionId,
+  findActionById,
+  flattenConfigFields,
+  generateAIActionPrompts,
+  getActionsByCategory,
+  getAllActions,
+  getAllDependencies,
+  getAllEnvVars,
+  getAllIntegrations,
+  getCodegenTemplate,
+  getCredentialMapping,
+  getDependenciesForActions,
+  getIntegration,
+  getIntegrationDescriptions,
+  getIntegrationLabels,
+  getIntegrationTypes,
+  getOutputDisplayConfig,
+  getPluginEnvVars,
+  getSortedIntegrationTypes,
+  isFieldGroup,
+  parseActionId,
+  registerCodegenTemplates,
+  registerIntegration,
+  registerOutputDisplayConfigs
+} from "../chunk-Z3BJJYHM.js";
+export {
+  computeActionId,
+  findActionById,
+  flattenConfigFields,
+  generateAIActionPrompts,
+  getActionsByCategory,
+  getAllActions,
+  getAllDependencies,
+  getAllEnvVars,
+  getAllIntegrations,
+  getCodegenTemplate,
+  getCredentialMapping,
+  getDependenciesForActions,
+  getIntegration,
+  getIntegrationDescriptions,
+  getIntegrationLabels,
+  getIntegrationTypes,
+  getOutputDisplayConfig,
+  getPluginEnvVars,
+  getSortedIntegrationTypes,
+  isFieldGroup,
+  parseActionId,
+  registerCodegenTemplates,
+  registerIntegration,
+  registerOutputDisplayConfigs
+};

package/dist/server/api/index.d.ts

@@ -0,0 +1,8 @@
+declare function GET(request: Request): Promise<Response>;
+declare function POST(request: Request): Promise<Response>;
+declare function PUT(request: Request): Promise<Response>;
+declare function PATCH(request: Request): Promise<Response>;
+declare function DELETE(request: Request): Promise<Response>;
+declare function OPTIONS(_request: Request): Promise<Response>;
+
+export { DELETE, GET, OPTIONS, PATCH, POST, PUT };