@adminide-stack/form-builder-core 5.1.4-alpha.66 → 5.1.4-alpha.82

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.1.4-alpha.82](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.81...v5.1.4-alpha.82) (2025-10-25)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
+## [5.1.4-alpha.81](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.80...v5.1.4-alpha.81) (2025-10-24)
+
+**Note:** Version bump only for package @adminide-stack/form-builder-core
+
 ## [5.1.4-alpha.66](https://github.com/CDEBase/forms-stack/compare/v5.1.4-alpha.65...v5.1.4-alpha.66) (2025-10-16)
 
 **Note:** Version bump only for package @adminide-stack/form-builder-core

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 export * from './inngest/interfaces/types';
 export * from './inngest/generateFunctionCode';
-export { generateFromExtractedFunctions } from './inngest/stepGenerator';
+export { generateFromExtractedFunctions, extractFunctionBody } from './inngest/stepGenerator';
 export * from './inngest/monacoAutocompleteIntegration';
+export * from './utils/json';
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,8BAA8B,EAAE,MAAM,yBAAyB,CAAC;AACzE,cAAc,yCAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,8BAA8B,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9F,cAAc,yCAAyC,CAAC;AACxD,cAAc,cAAc,CAAC"}

package/lib/index.js

@@ -1 +1 @@
-export{generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction}from'./inngest/generateFunctionCode.js';export{cleanStepCode,extractStepVarName,generateFromExtractedFunctions}from'./inngest/stepGenerator.js';export{getAvailableDefinitions,installLibraryForAutocomplete,setupMonacoAutocomplete,setupStepAutocomplete,updateAutocompleteConfig}from'./inngest/monacoAutocompleteIntegration.js';//# sourceMappingURL=index.js.map
+export{generateFunctionCode,generateHandlerBody,generateHandlerBodyWithReturn,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction}from'./inngest/generateFunctionCode.js';export{cleanStepCode,extractFunctionBody,extractStepVarName,generateFromExtractedFunctions}from'./inngest/stepGenerator.js';export{getAvailableDefinitions,installLibraryForAutocomplete,setupMonacoAutocomplete,setupStepAutocomplete,updateAutocompleteConfig}from'./inngest/monacoAutocompleteIntegration.js';export{flatten,unflatten}from'./utils/json.js';//# sourceMappingURL=index.js.map

package/lib/inngest/generateFunctionCode.d.ts

@@ -2,6 +2,7 @@ import type { InngestFunctionDef, ExtractedFunction, StepFunction, GeneratedFunc
 export { cleanStepCode, extractStepVarName } from './stepGenerator';
 export declare function generateFunctionCode(def: InngestFunctionDef): string;
 export declare function generateHandlerBody(def: InngestFunctionDef): string;
+export declare function generateHandlerBodyWithReturn(def: InngestFunctionDef): string;
 export declare function generateStepFunctionsFromDB(functionId: string, events: string[], extractedFunctions: ExtractedFunction[]): GeneratedFunctionResult;
 export declare function wrapStepsInInngestFunction(functionDef: InngestFunctionDef, stepFunctions: StepFunction[]): string;
 export declare function generateStepFromFunction(stepFunction: StepFunction, index: number): string;

package/lib/inngest/generateFunctionCode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateFunctionCode.d.ts","sourceRoot":"","sources":["../../src/inngest/generateFunctionCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,kBAAkB,EAElB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EAC1B,MAAM,oBAAoB,CAAC;AAS5B,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AA2DpE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAWpE;AAGD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAInE;AAGD,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EAAE,EAChB,kBAAkB,EAAE,iBAAiB,EAAE,GACxC,uBAAuB,CAazB;AAGD,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,kBAAkB,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,MAAM,CAWjH;AAGD,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAoB1F"}
+{"version":3,"file":"generateFunctionCode.d.ts","sourceRoot":"","sources":["../../src/inngest/generateFunctionCode.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACR,kBAAkB,EAElB,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EAC1B,MAAM,oBAAoB,CAAC;AAS5B,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAyEpE,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAWpE;AAGD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAInE;AAiDD,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAkC7E;AAGD,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EAAE,EAChB,kBAAkB,EAAE,iBAAiB,EAAE,GACxC,uBAAuB,CAazB;AAGD,wBAAgB,0BAA0B,CAAC,WAAW,EAAE,kBAAkB,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,MAAM,CAWjH;AAGD,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAoB1F"}

package/lib/inngest/generateFunctionCode.js

@@ -23,6 +23,16 @@ function formatCode(code) {
   // Basic formatting - in production, you'd use a proper formatter
   return code.split('\n').map(line => line.trimEnd()).join('\n').replace(/\n{3,}/g, '\n\n'); // Remove excessive blank lines
 }
+function sanitizeDirectStepCode(code) {
+  if (!code) {
+    return code;
+  }
+  return code
+  // Remove inline object returns (e.g. return { success: true };)
+  .replace(/\n\s*return\s*\{[\s\S]*?\};?/g, '')
+  // Remove simple expression returns (e.g. return result;)
+  .replace(/\n\s*return\s+[^\n;]+;?/g, '');
+}
 function generateStepBlock(step, position) {
   const stepVar = (step.code || '').match(/const\s+(\w+)\s*=/)?.[1] || `step_${position}`;
   // If caller supplied code, embed it inside step.run wrapper by default for consistency
@@ -34,7 +44,7 @@ ${body}`;
   }
   const inner = extractFunctionBody(step.code || '') || 'return { success: true };';
   return `// ${step.description || step.name || `Step ${position}`}
-const ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {
+const ${stepVar}_result = await step.run('${stepVar}', async () => {
 ${indent(inner, 2)}
 });`;
 }
@@ -57,6 +67,65 @@ function generateHandlerBody(def) {
   // Footer removed: callers should append their own consolidated return as needed
   return `${stepBlocks}`;
 }
+function escapeSingleQuotes(value) {
+  return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+function resolveStepVarName(step, index) {
+  const directMatch = (step.code || '').match(/const\s+(\w+)\s*=/);
+  if (directMatch) {
+    return directMatch[1];
+  }
+  if (typeof step.id === 'string' && step.id.trim()) {
+    return step.id;
+  }
+  return `step_${index + 1}`;
+}
+function resolveResultExpression(step, varName) {
+  switch (step.type) {
+    case 'sleep':
+      return 'sleepResult';
+    case 'sendEvent':
+      return 'eventResult';
+    case 'waitForEvent':
+      return 'waitResult';
+    default:
+      return `${varName}_result`;
+  }
+}
+function sanitizeSteps(def) {
+  const sanitizedSteps = def.steps.map(step => {
+    if (step.type === 'sleep' || step.type === 'sendEvent' || step.type === 'waitForEvent') {
+      return {
+        ...step,
+        code: sanitizeDirectStepCode(step.code || '')
+      };
+    }
+    return step;
+  });
+  return {
+    ...def,
+    steps: sanitizedSteps
+  };
+}
+function generateHandlerBodyWithReturn(def) {
+  const sanitizedDef = sanitizeSteps(def);
+  const body = generateHandlerBody(sanitizedDef).trimEnd();
+  const resultLines = sanitizedDef.steps.map((step, index) => {
+    const varName = resolveStepVarName(step, index);
+    const resultExpr = resolveResultExpression(step, varName);
+    if (!resultExpr) {
+      return null;
+    }
+    return `  ${varName}: ${resultExpr},`;
+  }).filter(line => Boolean(line));
+  const escapedId = escapeSingleQuotes(def.id || 'new-function');
+  const returnLines = ['return {', `  functionId: '${escapedId}',`, ...resultLines, '  timestamp: new Date().toISOString()', '};'];
+  const returnBlock = returnLines.join('\n');
+  if (!body) {
+    return returnBlock;
+  }
+  return `${body}\n\n${returnBlock}`;
+}
 // Generate Inngest function from database-extracted functions
 function generateStepFunctionsFromDB(functionId, events, extractedFunctions) {
   if (!extractedFunctions || extractedFunctions.length === 0) {
@@ -93,5 +162,5 @@ function generateStepFromFunction(stepFunction, index) {
   if (hasDirectOps) {
     return `// ${stepFunction.name || `Step ${index}`}\n${cleanedBody}`;
   }
-  return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {\n${indent(cleanedBody, 2)}\n});`;
-}export{cleanStepCode,extractStepVarName,generateFunctionCode,generateHandlerBody,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction};//# sourceMappingURL=generateFunctionCode.js.map
+  return `// ${stepFunction.name || `Step ${index}`}\nconst ${stepVar}_result = await step.run('${stepVar}', async () => {\n${indent(cleanedBody, 2)}\n});`;
+}export{cleanStepCode,extractStepVarName,generateFunctionCode,generateHandlerBody,generateHandlerBodyWithReturn,generateStepFromFunction,generateStepFunctionsFromDB,wrapStepsInInngestFunction};//# sourceMappingURL=generateFunctionCode.js.map

package/lib/inngest/generateFunctionCode.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateFunctionCode.js","sources":["../../src/inngest/generateFunctionCode.ts"],"sourcesContent":[null],"names":[],"mappings":"qHAyFA;AAOA,SAAA;AAoBA,EAAA,OAAA,+CAA2C,CAAA,IAAA,CAAW,IAAE,CAAA;AAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"generateFunctionCode.js","sources":["../../src/inngest/generateFunctionCode.ts"],"sourcesContent":[null],"names":[],"mappings":"qHAuGA;AAqDA,SAAA;AAqCA,EAAA,OAAA,+CACI,CAAA,IAAA,CAAU,IAAE,CAAA;AAmBhB;AAcA,SAAA,oBAAgB,CAAA,IAAA,EAAA,EAAA,EAAA,KAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/utils/json.d.ts

@@ -0,0 +1,3 @@
+export declare function flatten(obj: Record<string, unknown>, parentKey?: string, res?: Record<string, unknown>): Record<string, unknown>;
+export declare function unflatten(obj: Record<string, unknown>): {};
+//# sourceMappingURL=json.d.ts.map

package/lib/utils/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/utils/json.ts"],"names":[],"mappings":"AAAA,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,SAAK,EAAE,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,2BAoBtG;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,MA2BrD"}

package/lib/utils/json.js

@@ -0,0 +1,43 @@
+function flatten(obj, parentKey = '', res = {}) {
+  Object.entries(obj).forEach(([key, value]) => {
+    const newKey = parentKey ? `${parentKey}.${key}` : key;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (item !== null && typeof item === 'object') {
+          flatten(item, `${newKey}.${index}`, res);
+        } else {
+          res[`${newKey}.${index}`] = item;
+        }
+      });
+    } else if (value !== null && typeof value === 'object') {
+      flatten(value, newKey, res);
+    } else {
+      res[newKey] = value;
+    }
+  });
+  return res;
+}
+function unflatten(obj) {
+  const result = {};
+  if (!obj || typeof obj !== 'object') return result;
+  for (const [flatKey, value] of Object.entries(obj)) {
+    const keys = flatKey.split('.');
+    keys.reduce((acc, cur, i) => {
+      const isLast = i === keys.length - 1;
+      const nextKey = keys[i + 1];
+      const curIsIndex = !Number.isNaN(Number(cur));
+      const nextIsIndex = !Number.isNaN(Number(nextKey));
+      // If current key is numeric, treat parent as an array
+      if (curIsIndex) {
+        if (!Array.isArray(acc)) return [];
+      }
+      if (isLast) {
+        acc[cur] = value;
+      } else if (acc[cur] == null) {
+        acc[cur] = nextIsIndex ? [] : {};
+      }
+      return acc[cur];
+    }, result);
+  }
+  return result;
+}export{flatten,unflatten};//# sourceMappingURL=json.js.map

package/lib/utils/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sources":["../../src/utils/json.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA,SAAA,OAAA,CAAgB,GAAA,EAAA,cAAmB,EAAC,GAAA,GAAM,EAAE,EAAA;AAsB5C,EAAA,MAAA,CAAA,OAAA,CAAA,GAAA,CAAA,CAAA,OAAgB,CAAA,CAAA,CAAA,GAAU,EAAG,KAAE,CAAA,KAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/form-builder-core",
-    "version": "5.1.4-alpha.66",
+    "version": "5.1.4-alpha.82",
     "sideEffects": false,
     "type": "module",
     "main": "lib/index.js",
@@ -24,5 +24,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "38642244b69e8c665139fb1a3cbc5f4c524f99d5"
+    "gitHead": "d2f703901231f55e85e7d721754f8746cd2753cc"
 }

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from './inngest/interfaces/types';
 export * from './inngest/generateFunctionCode';
-export { generateFromExtractedFunctions } from './inngest/stepGenerator';
+export { generateFromExtractedFunctions, extractFunctionBody } from './inngest/stepGenerator';
 export * from './inngest/monacoAutocompleteIntegration';
+export * from './utils/json';

package/src/inngest/generateFunctionCode.ts

@@ -54,6 +54,20 @@ function formatCode(code: string): string {
         .replace(/\n{3,}/g, '\n\n'); // Remove excessive blank lines
 }
 
+function sanitizeDirectStepCode(code: string): string {
+    if (!code) {
+        return code;
+    }
+
+    return (
+        code
+            // Remove inline object returns (e.g. return { success: true };)
+            .replace(/\n\s*return\s*\{[\s\S]*?\};?/g, '')
+            // Remove simple expression returns (e.g. return result;)
+            .replace(/\n\s*return\s+[^\n;]+;?/g, '')
+    );
+}
+
 function generateStepBlock(step: InngestStep, position: number): string {
     const stepVar = (step.code || '').match(/const\s+(\w+)\s*=/)?.[1] || `step_${position}`;
 
@@ -67,7 +81,7 @@ ${body}`;
 
     const inner = extractFunctionBody(step.code || '') || 'return { success: true };';
     return `// ${step.description || step.name || `Step ${position}`}
-const ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {
+const ${stepVar}_result = await step.run('${stepVar}', async () => {
 ${indent(inner, 2)}
 });`;
 }
@@ -93,6 +107,89 @@ export function generateHandlerBody(def: InngestFunctionDef): string {
     return `${stepBlocks}`;
 }
 
+function escapeSingleQuotes(value: string): string {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function resolveStepVarName(step: InngestStep, index: number): string {
+    const directMatch = (step.code || '').match(/const\s+(\w+)\s*=/);
+    if (directMatch) {
+        return directMatch[1];
+    }
+
+    if (typeof step.id === 'string' && step.id.trim()) {
+        return step.id;
+    }
+
+    return `step_${index + 1}`;
+}
+
+function resolveResultExpression(step: InngestStep, varName: string): string {
+    switch (step.type) {
+        case 'sleep':
+            return 'sleepResult';
+        case 'sendEvent':
+            return 'eventResult';
+        case 'waitForEvent':
+            return 'waitResult';
+        default:
+            return `${varName}_result`;
+    }
+}
+
+function sanitizeSteps(def: InngestFunctionDef): InngestFunctionDef {
+    const sanitizedSteps = def.steps.map((step) => {
+        if (step.type === 'sleep' || step.type === 'sendEvent' || step.type === 'waitForEvent') {
+            return {
+                ...step,
+                code: sanitizeDirectStepCode(step.code || ''),
+            };
+        }
+        return step;
+    });
+
+    return {
+        ...def,
+        steps: sanitizedSteps,
+    };
+}
+
+export function generateHandlerBodyWithReturn(def: InngestFunctionDef): string {
+    const sanitizedDef = sanitizeSteps(def);
+    const body = generateHandlerBody(sanitizedDef).trimEnd();
+
+    const resultLines = sanitizedDef.steps
+        .map((step, index) => {
+            const varName = resolveStepVarName(step, index);
+            const resultExpr = resolveResultExpression(step, varName);
+
+            if (!resultExpr) {
+                return null;
+            }
+
+            return `  ${varName}: ${resultExpr},`;
+        })
+        .filter((line): line is string => Boolean(line));
+
+    const escapedId = escapeSingleQuotes(def.id || 'new-function');
+
+    const returnLines = [
+        'return {',
+        `  functionId: '${escapedId}',`,
+        ...resultLines,
+        '  timestamp: new Date().toISOString()',
+        '};',
+    ];
+
+    const returnBlock = returnLines.join('\n');
+
+    if (!body) {
+        return returnBlock;
+    }
+
+    return `${body}\n\n${returnBlock}`;
+}
+
 // Generate Inngest function from database-extracted functions
 export function generateStepFunctionsFromDB(
     functionId: string,
@@ -147,5 +244,5 @@ export function generateStepFromFunction(stepFunction: StepFunction, index: numb
 
     return `// ${
         stepFunction.name || `Step ${index}`
-    }\nconst ${stepVar}_result = await step.run('${stepVar}', async (event, step) => {\n${indent(cleanedBody, 2)}\n});`;
+    }\nconst ${stepVar}_result = await step.run('${stepVar}', async () => {\n${indent(cleanedBody, 2)}\n});`;
 }

package/src/inngest/stepGenerator.ts

@@ -463,7 +463,7 @@ export function transformStepForExecution(
 
     // For other step types, wrap in step.run()
     return `// ${stepLabel}
-        const ${stepFunction.varName}_result = await step.run('${stepFunction.varName}', async (event, step) => {
+        const ${stepFunction.varName}_result = await step.run('${stepFunction.varName}', async () => {
             ${cleanedBody}
         });`;
 }

package/src/utils/json.ts

@@ -0,0 +1,50 @@
+export function flatten(obj: Record<string, unknown>, parentKey = '', res: Record<string, unknown> = {}) {
+    Object.entries(obj).forEach(([key, value]) => {
+        const newKey = parentKey ? `${parentKey}.${key}` : key;
+
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                if (item !== null && typeof item === 'object') {
+                    flatten(item, `${newKey}.${index}`, res);
+                } else {
+                    res[`${newKey}.${index}`] = item;
+                }
+            });
+        } else if (value !== null && typeof value === 'object') {
+            flatten(value as Record<string, unknown>, newKey, res);
+        } else {
+            res[newKey] = value;
+        }
+    });
+
+    return res;
+}
+
+export function unflatten(obj: Record<string, unknown>) {
+    const result = {};
+    if (!obj || typeof obj !== 'object') return result;
+    for (const [flatKey, value] of Object.entries(obj)) {
+        const keys = flatKey.split('.');
+        keys.reduce((acc, cur, i) => {
+            const isLast = i === keys.length - 1;
+            const nextKey = keys[i + 1];
+            const curIsIndex = !Number.isNaN(Number(cur));
+            const nextIsIndex = !Number.isNaN(Number(nextKey));
+
+            // If current key is numeric, treat parent as an array
+            if (curIsIndex) {
+                if (!Array.isArray(acc)) return [];
+            }
+
+            if (isLast) {
+                acc[cur] = value;
+            } else if (acc[cur] == null) {
+                acc[cur] = nextIsIndex ? [] : {};
+            }
+
+            return acc[cur];
+        }, result);
+    }
+
+    return result;
+}