@examplary/cli 1.12.0 → 1.14.0

package/dist/commands/upload.js

@@ -38,6 +38,19 @@ export const uploadCommand = async (argv) => {
         console.log(`• Uploaded component ${componentType}`);
     }
     definition.components = components;
+    // Upload the bundled functions
+    const functions = {};
+    for (const [functionName, output] of Object.entries(result.functions)) {
+        // Upload source map first if it exists
+        let sourceMapStatement = "";
+        if (output.sourcemap) {
+            const url = await uploadFile(`function-${functionName}.js.map`, output.sourcemap, "application/json");
+            sourceMapStatement = `\n//# sourceMappingURL=${url}`;
+        }
+        functions[functionName] = await uploadFile(`function-${functionName}.js`, output.js + sourceMapStatement, "application/javascript");
+        console.log(`• Uploaded function ${functionName}`);
+    }
+    definition.functions = functions;
     // Upload styles if present
     if (result.styles) {
         definition.stylesheet = await uploadFile("styles.css", result.styles, "text/css");

package/dist/lib/bundle.d.ts

@@ -1,4 +1,10 @@
 export declare const buildComponent: (file: string) => Promise<{
     js: string;
     sourcemap: string;
+    sha256: string;
+}>;
+export declare const buildFunction: (file: string) => Promise<{
+    js: string;
+    sourcemap: string;
+    sha256: string;
 }>;

package/dist/lib/bundle.js

@@ -1,4 +1,8 @@
+import { createHash } from "crypto";
 import { build } from "esbuild";
+const calculateHash = (compiled) => {
+    return createHash("sha256").update(compiled).digest("hex");
+};
 export const buildComponent = async (file) => {
     const res = await build({
         entryPoints: [file],
@@ -23,5 +27,28 @@ export const buildComponent = async (file) => {
         sourcemap = Buffer.from(js.split(sourceMapStatement)[1].trim(), "base64").toString("utf-8");
         js = js.split(sourceMapStatement)[0].trim();
     }
-    return { js, sourcemap };
+    const sha256 = calculateHash(js);
+    return { js, sourcemap, sha256 };
+};
+export const buildFunction = async (file) => {
+    const res = await build({
+        entryPoints: [file],
+        bundle: true,
+        write: false,
+        minify: true,
+        sourcemap: "inline",
+        platform: "neutral",
+        mainFields: ["module", "main"],
+        format: "iife",
+        globalName: "userFunction",
+    });
+    let js = res.outputFiles[0].text;
+    let sourcemap = "";
+    const sourceMapStatement = "\n//# sourceMappingURL=data:application/json;base64,";
+    if (js.includes(sourceMapStatement)) {
+        sourcemap = Buffer.from(js.split(sourceMapStatement)[1].trim(), "base64").toString("utf-8");
+        js = js.split(sourceMapStatement)[0].trim();
+    }
+    const sha256 = calculateHash(js);
+    return { js, sourcemap, sha256 };
 };

package/dist/lib/response-processing.js

@@ -9,7 +9,10 @@ const evaluateCondition = async (condition, data) => {
         throw new Error("Invalid response processing condition: must start with '='");
     }
     const outcome = await jsonata(condition.substring(1)).evaluate(data);
-    return Boolean(outcome);
+    if (typeof outcome !== "boolean") {
+        throw new Error(`Response processing condition must evaluate to a boolean, got ${typeof outcome}`);
+    }
+    return outcome;
 };
 /**
  * Runs every `responseProcessing.testCases` through the `condition` and checks

package/dist/lib/validate.d.ts

@@ -18,6 +18,8 @@ export type ValidationResult = {
     styles?: string;
     /** Raw icon file contents, present only when an icon is configured. */
     iconContents?: string;
+    /** Bundled function output, keyed by function name, ready to upload. */
+    functions: Record<string, BuiltComponent>;
 };
 /**
  * Runs every check the `upload` command performs, short of actually uploading:

package/dist/lib/validate.js

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
 import { resolve } from "path";
-import { buildComponent } from "./bundle.js";
+import { buildComponent, buildFunction } from "./bundle.js";
 import { deepCompileJsonata } from "./jsonata.js";
 import { runResponseProcessingTestCases, } from "./response-processing.js";
 import { buildStyles } from "./styles.js";
@@ -20,6 +20,7 @@ export const validateDefinition = async (definition, dir) => {
     const errors = [];
     const warnings = [];
     const bundles = {};
+    const functions = {};
     let styles;
     let iconContents;
     if (!definition.id)
@@ -89,6 +90,21 @@ export const validateDefinition = async (definition, dir) => {
             errors.push(`Error bundling component ${componentType} from ${componentPath}: ${error.message}`);
         }
     }
+    // Bundle functions to confirm they build and to capture their output
+    for (const [functionName, functionPath] of Object.entries(definition.functions || {})) {
+        const realPath = resolve(dir, functionPath);
+        try {
+            const output = await buildFunction(realPath);
+            functions[functionName] = output;
+            const sizeInKb = output.js.length / 1000;
+            if (sizeInKb > 100) {
+                errors.push(`Function ${functionName} is larger than the 100 kB limit (${sizeInKb.toFixed(2)} kB)`);
+            }
+        }
+        catch (error) {
+            errors.push(`Error bundling function ${functionName} from ${functionPath}: ${error.message}`);
+        }
+    }
     // Build styles if any components are present
     if (Object.keys(bundles).length) {
         styles = (await buildStyles()) ?? undefined;
@@ -106,7 +122,15 @@ export const validateDefinition = async (definition, dir) => {
             errors.push(`Icon file is empty: ${iconPath}`);
         }
     }
-    return { errors, warnings, testCaseResults, bundles, styles, iconContents };
+    return {
+        errors,
+        warnings,
+        testCaseResults,
+        bundles,
+        functions,
+        styles,
+        iconContents,
+    };
 };
 /** Whether the definition is safe to upload. */
 export const isValid = (result) => result.errors.length === 0 && result.testCaseResults.every((r) => r.passed);
@@ -116,6 +140,10 @@ export const printValidationResult = (result) => {
         const sizeInKb = (output.js.length / 1000).toFixed(2);
         console.log(`• Bundled component ${componentType} (${sizeInKb} kB)`);
     }
+    for (const [functionName, output] of Object.entries(result.functions)) {
+        const sizeInKb = (output.js.length / 1000).toFixed(2);
+        console.log(`• Bundled function ${functionName} (${sizeInKb} kB)`);
+    }
     for (const warning of result.warnings) {
         console.warn(`  ⚠️ ${warning.message}`);
         if (warning.file && process.env.GITHUB_ACTIONS) {