> ## 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.

# Set Property

> Index pipeline stage configuration specifications

export const schema = {
  "type": "object",
  "title": "Set Property",
  "description": "Conditionally sets a value on the pipeline document or in the pipeline context based on the presence, content, or regex match of source fields. Evaluates one or more simple conditions and writes the output value when any condition returns `true`. For complex conditional logic, use the JavaScript condition available on the stage.",
  "required": ["outputType"],
  "properties": {
    "skip": {
      "type": "boolean",
      "title": "Skip This Stage",
      "description": "Controls whether this stage executes during pipeline processing at runtime. When set to `true`, the stage is completely bypassed and documents pass through unchanged to the next stage. Useful for A/B testing, gradual rollouts, or temporarily disabling a stage without removing it from the pipeline.",
      "default": false,
      "hints": ["advanced"]
    },
    "label": {
      "type": "string",
      "title": "Label",
      "description": "Human-readable identifier displayed in the Fusion Admin UI, monitoring dashboards, and log messages. Use descriptive labels like `Parse Product PDFs` to aid debugging and team collaboration. Labels appear in performance metrics and error reports, making it easier to identify which stage failed.",
      "hints": ["advanced"],
      "maxLength": 255
    },
    "condition": {
      "type": "string",
      "title": "Condition",
      "description": "JavaScript expression evaluated at runtime on each document to conditionally execute this stage. The expression must return `true` to execute or `false` to skip. Access document fields using `doc.getFieldValue('fieldName')` and request parameters via `request.getFirstParam('paramName')`. For example, `doc.getFieldValue('type') === 'premium'` executes this stage only for premium content.",
      "hints": ["code", "code/javascript", "advanced"]
    },
    "source": {
      "type": "array",
      "title": "Source",
      "description": "Specifies the source field names or context keys evaluated as the condition input. When only source fields are configured with no other conditions, the property is set only if all listed fields are present and non-null on the document. Supports String Template expressions for dynamic field references.",
      "items": {
        "type": "string"
      }
    },
    "ifEquals": {
      "type": "string",
      "title": "If Value Equals",
      "description": "Specifies a value to compare against the source field value to trigger the output. Accept another field or context key reference, the keyword `null` or `not null`, or a literal string in quotes such as `\"match\"`. Supports String Template expressions for dynamic comparison values."
    },
    "regularExpression": {
      "type": "string",
      "title": "Regular Expression Match",
      "description": "Applies a regular expression to each source field value and sets the output property when any value matches. The implementation returns `true` when the pattern matches anywhere within the string, not just at the start. Use anchors such as `^` and `$` for full-value matching."
    },
    "outputKey": {
      "type": "string",
      "title": "Output Key",
      "description": "Specifies the name of the key written to the output location, either the document or the pipeline context. Supports String Template expressions for dynamic key names. The key must be unique within the output location to avoid overwriting existing values unintentionally.",
      "default": "setPropertyKey"
    },
    "outputValue": {
      "type": "string",
      "title": "Output Value",
      "description": "Specifies the value written to the output key when one or more conditions match. Supports String Template expressions for dynamic values. The value is written to the document or context depending on the `outputType` setting.",
      "default": "true"
    },
    "falseOutputValue": {
      "type": "string",
      "title": "False Output Value",
      "description": "Specifies the value written to the output key when no conditions match. When empty or `null`, nothing is written and the output key is left unchanged. Use this to set a default or sentinel value when the condition evaluation returns false."
    },
    "whatMatchedKey": {
      "type": "string",
      "title": "What Matched Key",
      "description": "Specifies the pipeline context key where a space-separated list of matched condition identifiers is stored after evaluation. Use this to inspect which conditions fired for debugging or downstream logic. The key is always written to the context regardless of the `outputType` setting.",
      "default": "whatMatched"
    },
    "outputType": {
      "type": "string",
      "title": "Output Type",
      "description": "Determines whether the output key and value are written to the pipeline document or the pipeline context. Use `document` to add a field to the indexed document and `context` to pass a value to downstream pipeline stages without modifying the document.",
      "enum": ["document", "context"],
      "default": "context"
    }
  },
  "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 renderMd = str => {
    const s = sanitize(str);
    const text = (/[.!?]\)*$/).test(s) ? s : `${s}.`;
    return text.split(/(\*\*[^*]+\*\*|_[^_]+_|`[^`]+`)/g).map((part, i) => {
      if (part.startsWith("**")) return <strong key={i}>{part.slice(2, -2)}</strong>;
      if (part.startsWith("_")) return <em key={i}>{part.slice(1, -1)}</em>;
      if (part.startsWith("`")) return <code key={i}>{part.slice(1, -1)}</code>;
      return part;
    });
  };
  const {description, properties = {}, required: requiredProps = []} = schema;
  const visibleProps = useMemo(() => Object.entries(properties).filter(([, prop]) => !prop.hints?.includes("hidden")), [properties]);
  const renderProp = ([name, prop]) => {
    const isRequired = requiredProps.includes(name);
    const hasDefault = prop.default !== undefined;
    const rawDefault = prop.default;
    const hints = prop.hints || [];
    const isComplexDefault = hasDefault && (typeof rawDefault === "object" || typeof rawDefault === "string" && (rawDefault.length > 20 || rawDefault.includes('"')));
    const postBadges = [];
    if (prop.title) {
      postBadges.push(<><span className="text-stone-400 dark:text-stone-500">API property: </span>{name}</>);
    }
    const constraints = [];
    if (prop.minimum !== undefined && prop.maximum !== undefined) {
      constraints.push(`Range: ${prop.minimum} – ${prop.maximum}`);
    } else if (prop.minimum !== undefined) {
      constraints.push(`Min: ${prop.minimum}`);
    } else if (prop.maximum !== undefined) {
      constraints.push(`Max: ${prop.maximum}`);
    }
    if (prop.minLength !== undefined && prop.maxLength !== undefined) {
      constraints.push(`Length: ${prop.minLength} – ${prop.maxLength}`);
    } else if (prop.minLength !== undefined) {
      constraints.push(`Min length: ${prop.minLength}`);
    } else if (prop.maxLength !== undefined) {
      constraints.push(`Max length: ${prop.maxLength}`);
    }
    const fieldProps = {
      key: name,
      body: prop.title || name,
      type: prop.type,
      ...postBadges.length > 0 && ({
        post: postBadges
      }),
      ...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>{renderMd(prop.description)}</p>}

        {prop.enum && <p>
            Allowed values: 
            {prop.enum.map((v, i) => <>{i > 0 && ", "}<code key={i}>{String(v)}</code></>)}
          </p>}

        {constraints.length > 0 && <p className="text-stone-500 dark:text-stone-400 text-sm">
            {constraints.join(" · ")}
          </p>}

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

        {isArrayOfObjects && <Expandable title="item properties">
            <SchemaParamFields schema={{
      properties: prop.items.properties,
      required: prop.items.required
    }} />
          </Expandable>}

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

      {visibleProps.map(renderProp)}
    </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/lucidworks-search/09-developer-documentation/config-specs/index-pipeline-stages/set-property

[mintlify link]: https://doc.lucidworks.com/docs/lucidworks-search/09-developer-documentation/config-specs/index-pipeline-stages/set-property

[old doc.lw link]: https://doc.lucidworks.com/managed-fusion/5.9/9fqkkx

The Set Property Index Stage is used to set a value on a document, or into the Pipeline Context for downstream consumption
by specifying a series of simple matching conditions.
These conditions match against whether a field exists, and simple substring matches on the field contents.
For more complex logic, use a [JavaScript Index Stage](/docs/lucidworks-search/09-developer-documentation/config-specs/index-pipeline-stages/javascript).

<LwTemplate />

## 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} />