> ## Documentation Index
> Fetch the complete documentation index at: https://doc.lucidworks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Managed JavaScript Index Stage

export const schema = {
  "type": "object",
  "title": "Managed JavaScript",
  "description": "Run a JavaScript transformation on documents using a script from the Blob Service. This stage allows to run arbitrary code on the server.",
  "required": ["ref"],
  "properties": {
    "skip": {
      "type": "boolean",
      "title": "Skip This Stage",
      "description": "Set to true to skip this stage.",
      "default": false,
      "hints": ["advanced"]
    },
    "label": {
      "type": "string",
      "title": "Label",
      "description": "A unique label for this stage.",
      "hints": ["advanced"],
      "maxLength": 255
    },
    "condition": {
      "type": "string",
      "title": "Condition",
      "description": "Define a conditional script that must result in true or false. This can be used to determine if the stage should process or not.",
      "hints": ["code", "code/javascript", "advanced"]
    },
    "ref": {
      "type": "string",
      "title": "Script Reference",
      "description": "Reference to a Javascript Blob with Blob type file:js-index.",
      "reference": "blob",
      "blobType": "file:js-index"
    }
  },
  "category": "Advanced",
  "categoryPriority": 3,
  "unsafe": false
};

export const SchemaParamFields = ({schema}) => {
  const sanitize = str => {
    if (typeof str !== "string") return str;
    return str.replace(/^"(.*)"$/s, "$1").replace(/\\/g, "").replace(/"/g, "'");
  };
  const formatDescription = str => {
    const s = sanitize(str);
    return (/[.!?]\)*$/).test(s) ? s : `${s}.`;
  };
  const {description, properties = {}, required: requiredProps = []} = schema;
  const visibleProps = useMemo(() => Object.entries(properties).filter(([, prop]) => !prop.hints?.includes("hidden")), [properties]);
  return <div>
      {description && <p>{formatDescription(description)}</p>}

      {visibleProps.map(([name, prop]) => {
    const isRequired = requiredProps.includes(name);
    const hasDefault = prop.default !== undefined;
    const rawDefault = prop.default;
    const isComplexDefault = hasDefault && (typeof rawDefault === "object" || typeof rawDefault === "string" && (rawDefault.length > 20 || rawDefault.includes('"')));
    const fieldProps = {
      key: name,
      body: prop.title || name,
      type: prop.type,
      ...prop.title && ({
        post: [<><span className="text-stone-400 dark:text-stone-500">API property: </span>{name}</>]
      }),
      ...isRequired && ({
        required: true
      }),
      ...!isComplexDefault && hasDefault ? {
        default: sanitize(String(rawDefault))
      } : {}
    };
    const isObject = prop.type === "object" && prop.properties;
    const isArrayOfObjects = prop.type === "array" && prop.items?.type === "object" && prop.items.properties;
    return <ParamField {...fieldProps}>
            {prop.description && <p>{formatDescription(prop.description)}</p>}

            {isComplexDefault && <div className="flex">
                <p>
                  <strong>Default:</strong>
                </p>
                <pre className="!my-0">
                  <code>
                    {JSON.stringify(rawDefault, null, 2)}
                  </code>
                </pre>
              </div>}

            {isArrayOfObjects && <div className="flex">
              <p>
                <strong>Object attributes:</strong>
              </p>
              <pre className="!my-0">
                <code>
                  {'{\n'}
                  {Object.entries(prop.items.properties).map(([iname, iprop]) => <>
                      {`  ${iname}`}
                      {prop.items?.required?.includes(iname) && <span style={{
      color: 'red'
    }}> required</span>}
                      {`: {\n    display name: ${sanitize(iprop.title || '')}\n    type: ${iprop.type}\n  }\n`}
                    </>)}
                  {'}'}
                </code>
              </pre>
              </div>}

            {isObject && <Expandable title="properties">
                <SchemaParamFields schema={{
      properties: prop.properties,
      required: prop.required
    }} />
              </Expandable>}
          </ParamField>;
  })}
    </div>;
};

export const LwTemplate = ({title = "Key questions to get you started", icon = "sparkles", cta = "Powered by Agent Studio", linkHref = "https://lucidworks.com/demo/?utm_source=docs&utm_medium=referral&utm_campaign=docs_cta_ai"}) => {
  const [isLoaded, setIsLoaded] = useState(false);
  useEffect(() => {
    const timer = setTimeout(() => {
      setIsLoaded(true);
    }, 500);
    return () => clearTimeout(timer);
  }, []);
  return <div className="lw-template-container">
      <Card title={title} icon={icon}>
        {isLoaded && <span dangerouslySetInnerHTML={{
    __html: `<lw-template id="a029c1a9-28be-427e-b0e1-5d918920246a"></lw-template
            >`
  }} />}
        <Link href={linkHref} className="agent-studio-link text-left text-gray-600 gap-2 dark:text-gray-400 text-sm font-medium flex flex-row items-center hover:text-primary dark:hover:text-primary-light group-hover:text-primary group-hover:dark:text-primary-light">Powered by Lucidworks Agent Studio</Link>
      </Card>
    </div>;
};

[localhost link]: http://localhost:3000/docs/5/fusion/reference/config-ref/pipeline-stages/index-stages/managed-javascript-index-stage

[mintlify link]: https://doc.lucidworks.com/docs/5/fusion/reference/config-ref/pipeline-stages/index-stages/managed-javascript-index-stage

[old doc.lw link]: https://doc.lucidworks.com/fusion/5.9/217

This stage runs a JavaScript transformation on documents using a script from the [blob store](/docs/5/fusion/getting-data-in/blob-storage). The script must have the blob type `file:js-index`.

<LwTemplate />

## Uploading a JavaScript blob

In Fusion 5.9, JavaScript blobs must be uploaded using the [Blob Store API](/api-reference/blobs/get-blob-store-service-status), like this:

```bash wrap  theme={"dark"}
curl -u USERNAME:PASSWORD -X PUT -H 'Content-Type: text/javascript' --data-binary @index-pipeline-js-stage.js http://FUSION_HOST:FUSION_PORT/api/apps/APP_NAME/blobs/index-pipeline-js-stage.js?resourceType=file:js-index
```

Open the [blob manager](/docs/5/fusion/getting-data-in/blob-storage) to verify that the new blob is present:

<img src="https://mintcdn.com/lucidworks/qCaM85k6rX7hs1DP/assets/images/4.1/known-issue-APOLLO-15672-index.png?fit=max&auto=format&n=qCaM85k6rX7hs1DP&q=85&s=23a4be4a1a7b30ad442d6cd53ee54ded" alt="Uploaded JavaScript blob in the blob manager" width="614" height="600" data-path="assets/images/4.1/known-issue-APOLLO-15672-index.png" />

## Referencing a JavaScript blob

Use any of the following formats for the `ref`/**Script Reference** configuration field:

```sh wrap  theme={"dark"}
index-pipeline-js-stage.js
```

```sh wrap  theme={"dark"}
blob:index-pipeline-js-stage.js
```

```sh wrap  theme={"dark"}
urn:x-fusion:blob:index-pipeline-js-stage.js
```

<Note>
  The examples above use `index-pipeline-js-stage.js` as the blob ID.
</Note>

## Edit JavaScript

For Fusion 5.4.x and later, select **Edit** in the **Script Reference** field to edit JavaScript directly in the Fusion UI.

## JavaScript examples

<Note>
  When reusing a script in both Managed JavaScript index stages and Managed JavaScript query stages, you need to upload it twice: once as a `file:js-index` blob and once as a `file:js-query` blob.
</Note>

### Set up a reusable library

This is an example of a reusable JavaScript library that provides various utility functions for string processing, date handling, and type conversion.
To reuse Javascript functions, create a stage like this one that defines them, then place it *before* any of the stages that use it.

```js wrap  theme={"dark"}
/* globals Java, logger*/
//JavaScript (ES5.1)
/**
 * UtilitiesDemoLib - A stripped-down demo utility library for Fusion Pipeline scripts
 *
 * Contains essential utility functions for demonstration purposes:
 * - Debug logging
 * - Type checking
 * - String manipulation
 *
 * This library is designed to work in both Index and Query pipelines
 * and automatically registers itself in the pipeline context.
 */
(function () {
    "use strict";

    var libName = 'UtilitiesDemoLib'
    var exports = {};

    /** Debug flag for conditional logging */
    var isDebug = false;

    /**
     * Conditional debug logging function
     * @param {string} m - Primary message to log
     * @param {...*} args - Additional arguments to log
     */
    function logIfDebug(m) {
        if (isDebug && m) {
            logger.info(m, Array.prototype.slice.call(arguments).slice(1));
        }
    }

    /**
     * Enables or disables debug logging for this library
     * @param {boolean} debug_b - true to enable debug logging, false to disable
     */
    function setDebugLogging(debug_b) {
        isDebug = debug_b;
        logIfDebug("Debug logging {} for {}", isDebug ? "enabled" : "disabled", libName);
    }

    /**
     * Returns the name of this library
     * @return {string} The library name
     */
    function getLibName() {
        return libName;
    }

    /**
     * Tests whether an object is a Java object by checking for standard Java methods
     * @param {*} obj - Object to test
     * @return {boolean} true if the object appears to be a Java object
     */
    function isJavaType(obj) {
        if (obj === null || obj === undefined) {
            return false;
        }

        // Check for common Java object methods
        return (typeof obj.getClass === 'function' ||
                typeof obj.hashCode === 'function' ||
                typeof obj.toString === 'function' && obj.constructor.name !== 'String');
    }

    /**
     * Returns a simplified type name for both Java and JavaScript objects
     * For Java objects: returns simple class name (e.g., 'String' for java.lang.String)
     * For JavaScript objects: returns lowercase type name (e.g., 'string')
     * @param {*} obj - Object to get type information for
     * @param {boolean} [verbose=false] - If true, return full Java class name
     * @return {string} Type name of the object
     */
    function getTypeOf(obj, verbose) {
        if (obj === null) return 'null';
        if (obj === undefined) return 'undefined';

        if (isJavaType(obj)) {
            try {
                var className = obj.getClass().getName();
                if (verbose) {
                    return className;
                } else {
                    // Return simple class name (last part after final dot)
                    return className.substring(className.lastIndexOf('.') + 1);
                }
            } catch (e) {
                return 'JavaObject';
            }
        } else {
            // JavaScript object
            return typeof obj;
        }
    }

    /**
     * Remove whitespace from start and end of str. Also remove redundant whitespace (set to space).
     * @param {string} str - String to trim
     * @return {string} Trimmed string with normalized whitespace
     */
    function trimWhitespace(str) {
        if (!str || typeof str !== 'string') {
            return str;
        }

        // Trim leading/trailing whitespace and normalize internal whitespace
        return str.trim().replace(/\s+/g, ' ');
    }

    // Export all utility functions for external use
    exports.setDebugLogging = setDebugLogging;
    exports.getLibName = getLibName;
    exports.isJavaType = isJavaType;
    exports.getTypeOf = getTypeOf;
    exports.trimWhitespace = trimWhitespace;

    /**
     * Auto-registration function for pipeline contexts
     * Detects pipeline type (Index vs Query) and registers this library in the context
     *
     * For Index Pipelines: arguments are (doc, ctx, collection, solrClient, solrFactory)
     * For Query Pipelines: arguments are (request, response, ctx, ...)
     *
     * The function identifies the context object by checking argument types and
     * registers the library functions under the library name for easy access
     *
     * @return {*} Returns the document object for Index pipelines, undefined for Query pipelines
     */
    return function main() {
        var doc, ctx;

        // Detect pipeline type by argument pattern
        if (arguments.length >= 3) {
            if (arguments[0] && typeof arguments[0].getId === 'function') {
                // Index Pipeline: (doc, ctx, collection, solrClient, solrFactory)
                doc = arguments[0];
                ctx = arguments[1];
            } else if (arguments[0] && typeof arguments[0].getParam === 'function') {
                // Query Pipeline: (request, response, ctx, collection, solrClient, solrFactory)
                ctx = arguments[2];
            }
        }

        if (ctx && typeof ctx.put === 'function') {
            // Register this library in the context
            var lib = {
                setDebugLogging: setDebugLogging,
                getLibName: getLibName,
                isJavaType: isJavaType,
                getTypeOf: getTypeOf,
                trimWhitespace: trimWhitespace
            };

            ctx.put(libName, lib);
            logIfDebug("Registered {} in pipeline context", libName);
        }

        // Return doc for Index pipelines (required), undefined for Query pipelines
        return doc;
    };
})();
```

## Configuration

<Tip>
  When entering configuration values in the UI, use *unescaped* characters, such as `\t` for the tab character. When entering configuration values in the API, use *escaped* characters, such as `\\t` for the tab character.
</Tip>

<SchemaParamFields schema={schema} />