isc-transforms-mcp 1.0.10 → 1.0.12

package/JSONS/sailpoint.isc.transforms.dateFormat.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "sailpoint.isc.transforms.dateFormat.schema.json",
   "title": "SailPoint ISC Transform Schema - dateFormat",
-  "description": "Strict schema derived from SailPoint official Date Format operation documentation. Converts datetime strings from one format to another. inputFormat/outputFormat may be Java SimpleDateFormat patterns or built-in named formats (ISO8601, LDAP, PEOPLE_SOFT, EPOCH_TIME_JAVA, EPOCH_TIME_WIN32). Note: The docs state this transform does not support the 'now' keyword as an input value.",
+  "description": "Strict schema for the SailPoint ISC Date Format transform. Converts a datetime string from one format to another using Java SimpleDateFormat patterns or 5 named formats: ISO8601, LDAP, PEOPLE_SOFT, EPOCH_TIME_JAVA, EPOCH_TIME_WIN32. IMPORTANT: The 'now' keyword is NOT supported as an input value for this transform.",
   "type": "object",
   "additionalProperties": false,
   "required": [
@@ -11,55 +11,61 @@
   ],
   "properties": {
     "type": {
-      "const": "dateFormat"
+      "const": "dateFormat",
+      "description": "Transform operation type. Must be exactly 'dateFormat'."
     },
     "name": {
       "type": "string",
-      "minLength": 1
+      "minLength": 1,
+      "description": "Display name for this transform, shown in UI dropdowns and identity profile mappings."
     },
     "requiresPeriodicRefresh": {
       "type": "boolean",
       "default": false,
-      "description": "Whether the transform logic should be reevaluated nightly as part of identity refresh. Default false."
+      "description": "If true, re-evaluates this transform during the nightly identity refresh cycle. Default is false."
     },
     "attributes": {
       "type": "object",
-      "description": "Date format configuration (optional). If omitted, inputFormat and outputFormat default to ISO8601.",
+      "description": "Date format configuration. All attributes are optional — inputFormat and outputFormat both default to ISO8601 if omitted.",
       "additionalProperties": false,
       "properties": {
         "inputFormat": {
           "default": "ISO8601",
-          "description": "Format of the incoming date. Must be one of the 5 named formats or a Java SimpleDateFormat pattern.",
+          "description": "Format of the incoming date string. Default is ISO8601. Accepts one of the 5 named formats OR any Java SimpleDateFormat pattern. Named formats: ISO8601 (yyyy-MM-dd'T'HH:mm:ss.SSSZ), LDAP (yyyyMMddHHmmss.Z), PEOPLE_SOFT (MM/dd/yyyy), EPOCH_TIME_JAVA (milliseconds since Jan 1 1970), EPOCH_TIME_WIN32 (100-nanosecond intervals since Jan 1 1601).",
           "anyOf": [
             {
               "enum": ["ISO8601", "LDAP", "PEOPLE_SOFT", "EPOCH_TIME_JAVA", "EPOCH_TIME_WIN32"],
-              "description": "Built-in named format."
+              "description": "Built-in named format. ISO8601=yyyy-MM-dd'T'HH:mm:ss.SSSZ, LDAP=yyyyMMddHHmmss.Z, PEOPLE_SOFT=MM/dd/yyyy, EPOCH_TIME_JAVA=ms since 1970, EPOCH_TIME_WIN32=100ns intervals since 1601."
             },
             {
               "type": "string",
               "not": { "pattern": "^[A-Z][A-Z0-9_]+$" },
-              "description": "Java SimpleDateFormat pattern (e.g. dd-MM-yyyy, yyyy-MM-dd'T'HH:mm:ssZ)."
+              "description": "Java SimpleDateFormat pattern (e.g. 'M/d/yyyy', 'dd-MM-yyyy', \"yyyy-MM-dd'T'HH:mm:ssZ\"). Must contain at least one date token."
             }
           ]
         },
         "outputFormat": {
           "default": "ISO8601",
-          "description": "Desired output format. Must be one of the 5 named formats or a Java SimpleDateFormat pattern.",
+          "description": "Desired output format. Default is ISO8601. Accepts one of the 5 named formats OR any Java SimpleDateFormat pattern. Named formats: ISO8601 (yyyy-MM-dd'T'HH:mm:ss.SSSZ), LDAP (yyyyMMddHHmmss.Z), PEOPLE_SOFT (MM/dd/yyyy), EPOCH_TIME_JAVA (milliseconds since Jan 1 1970), EPOCH_TIME_WIN32 (100-nanosecond intervals since Jan 1 1601).",
           "anyOf": [
             {
               "enum": ["ISO8601", "LDAP", "PEOPLE_SOFT", "EPOCH_TIME_JAVA", "EPOCH_TIME_WIN32"],
-              "description": "Built-in named format."
+              "description": "Built-in named format. ISO8601=yyyy-MM-dd'T'HH:mm:ss.SSSZ, LDAP=yyyyMMddHHmmss.Z, PEOPLE_SOFT=MM/dd/yyyy, EPOCH_TIME_JAVA=ms since 1970, EPOCH_TIME_WIN32=100ns intervals since 1601."
             },
             {
               "type": "string",
               "not": { "pattern": "^[A-Z][A-Z0-9_]+$" },
-              "description": "Java SimpleDateFormat pattern (e.g. dd-MM-yyyy, yyyy-MM-dd'T'HH:mm:ssZ)."
+              "description": "Java SimpleDateFormat pattern (e.g. 'yyyy-MM-dd', \"yyyy-MM-dd'T'HH:mm:ssZ\"). Must contain at least one date token."
             }
           ]
         },
         "input": {
-          "description": "Explicitly defines the input data passed into the transform. Docs specify an object; in practice this is a nested transform object. If omitted, the transform uses the UI-configured source+attribute input.",
-          "oneOf": [
+          "description": "Explicitly defines the input data passed into the transform. Can be a static date string matching the inputFormat pattern, or a nested transform object whose output is a date string. NOTE: The 'now' keyword is NOT supported by dateFormat — use dateMath instead for current-time operations.",
+          "anyOf": [
+            {
+              "type": "string",
+              "description": "Static date string that matches the inputFormat pattern (e.g., '4/1/1975' for inputFormat 'M/d/yyyy', or '144642632190' for EPOCH_TIME_JAVA). The 'now' keyword is NOT supported."
+            },
             {
               "$ref": "#/$defs/NestedTransform"
             }
@@ -71,7 +77,7 @@
   "$defs": {
     "NestedTransform": {
       "type": "object",
-      "description": "Nested transform object used for explicit input.",
+      "description": "A nested transform object whose output is used as the input date string for this dateFormat transform. Common use: accountAttribute to pull a date from a source, or dateMath to compute a relative date. The 'name' field is optional in nested transforms per SailPoint docs.",
       "additionalProperties": false,
       "required": [
         "type",
@@ -79,18 +85,22 @@
       ],
       "properties": {
         "id": {
-          "type": "string"
+          "type": "string",
+          "description": "Optional ID when referencing an existing saved transform."
         },
         "name": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "description": "Optional display name for the nested transform."
         },
         "type": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "description": "The operation type of the nested transform (e.g., 'accountAttribute', 'dateMath', 'static')."
         },
         "requiresPeriodicRefresh": {
-          "type": "boolean"
+          "type": "boolean",
+          "description": "Whether this nested transform re-evaluates during nightly refresh."
         },
         "attributes": {
           "type": "object",
@@ -102,20 +112,52 @@
   },
   "examples": [
     {
+      "name": "Java Epoch to ISO8601",
       "type": "dateFormat",
-      "name": "Date Format Transform",
       "attributes": {
         "inputFormat": "EPOCH_TIME_JAVA",
         "outputFormat": "ISO8601"
       }
     },
     {
+      "name": "US Date to Database Format",
       "type": "dateFormat",
-      "name": "Date Format Transform (US date to DB)",
       "attributes": {
         "inputFormat": "M/d/yyyy",
         "outputFormat": "yyyy-MM-dd"
       }
+    },
+    {
+      "name": "Static Date String Conversion",
+      "type": "dateFormat",
+      "attributes": {
+        "input": "12/31/1995",
+        "inputFormat": "M/d/yyyy",
+        "outputFormat": "ISO8601"
+      }
+    },
+    {
+      "name": "Source Hire Date to ISO8601",
+      "type": "dateFormat",
+      "attributes": {
+        "input": {
+          "type": "accountAttribute",
+          "attributes": {
+            "sourceName": "HR Source",
+            "attributeName": "hire_date"
+          }
+        },
+        "inputFormat": "MM/dd/yyyy",
+        "outputFormat": "ISO8601"
+      }
+    },
+    {
+      "name": "PeopleSoft Date to LDAP Format",
+      "type": "dateFormat",
+      "attributes": {
+        "inputFormat": "PEOPLE_SOFT",
+        "outputFormat": "LDAP"
+      }
     }
   ]
 }

package/JSONS/sailpoint.isc.transforms.dateMath.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "sailpoint.isc.transforms.dateMath.schema.json",
   "title": "SailPoint ISC Transform Schema - dateMath",
-  "description": "Strict schema derived from the SailPoint official Date Math operation documentation. Adds/subtracts/rounds components of an incoming ISO8601 UTC timestamp, or uses the keyword 'now'. Other considerations from docs: input must be ISO8601 UTC; rounding by 'week' is not supported; if 'now' is used and an 'input' attribute is also provided, the transform prefers 'now' and ignores 'input'. Output format is yyyy-MM-dd'T'HH:mm (not ISO8601); convert to ISO8601 via dateFormat when embedding in other transforms.",
+  "description": "Strict schema for the SailPoint ISC Date Math transform. Adds, subtracts, and rounds components of a datetime using 'now' or an explicit ISO8601 UTC input. IMPORTANT CONSTRAINTS: (1) Input must be ISO8601 UTC format (yyyy-MM-dd'T'HH:mm:ss.SSSZ). (2) Output format is 'yyyy-MM-dd\\'T\\'HH:mm' — NOT full ISO8601; wrap with dateFormat outputFormat: ISO8601 when nesting in other transforms. (3) Week rounding (/w) is not supported. (4) If expression uses 'now' and an input attribute is also provided, 'now' takes precedence and input is ignored.",
   "type": "object",
   "additionalProperties": false,
   "required": [
@@ -12,16 +12,18 @@
   ],
   "properties": {
     "type": {
-      "const": "dateMath"
+      "const": "dateMath",
+      "description": "Transform operation type. Must be exactly 'dateMath'."
     },
     "name": {
       "type": "string",
-      "minLength": 1
+      "minLength": 1,
+      "description": "Display name for this transform, shown in UI dropdowns and identity profile mappings."
     },
     "requiresPeriodicRefresh": {
       "type": "boolean",
       "default": false,
-      "description": "Whether the transform logic should be reevaluated nightly as part of identity refresh. Default false."
+      "description": "If true, re-evaluates this transform during the nightly identity refresh cycle. RECOMMENDED when expression uses 'now', so the computed date stays current. Default is false."
     },
     "attributes": {
       "type": "object",
@@ -33,21 +35,17 @@
         "expression": {
           "type": "string",
           "minLength": 1,
-          "description": "Date-math expression. Allowed units: y, M, w, d, h, m, s and keyword 'now'. Allowed operators: +, -, / (round). Docs note rounding with week is not supported.",
-          "pattern": "^(?!.*\\/w)(?:now|[0-9yMwdhms+\\-\\/]+)$"
+          "pattern": "^(?!\\.*/w)(now[+\\-\\/0-9yMwdhms]*|[+\\-\\/][0-9yMwdhms+\\-\\/]*)$",
+          "description": "Date-math expression defining the operation. Valid time units: y(year) M(month) w(week) d(day) h(hour) m(minute) s(second). Keyword 'now' = current datetime (must be at start). Operators: +(add) -(subtract) /(round — must be last, NOT /w). No whitespace allowed. Examples: 'now' | 'now/h' | 'now-5d/d' | 'now+1w' | '+3M' | '+12h/s' | 'now+1y+1M+2d-4h+1m-3s/s'. NOTE: output is yyyy-MM-dd'T'HH:mm — wrap with dateFormat for ISO8601."
         },
         "roundUp": {
           "type": "boolean",
           "default": false,
-          "description": "When expression includes rounding '/', true rounds up (truncate + add one unit); false truncates only. Default false."
+          "description": "Controls rounding direction when the '/' operator is used. true = round up (truncate to unit then add one unit). false = round down (truncate only, default). Has NO effect if expression does not contain '/'."
         },
         "input": {
-          "description": "Explicitly defines the input data passed into the transform (nested transform object). If omitted, uses UI-configured input.",
-          "oneOf": [
-            {
-              "$ref": "#/$defs/NestedTransform"
-            }
-          ]
+          "description": "Nested transform providing the input datetime. Output of the nested transform must be ISO8601 UTC (yyyy-MM-dd'T'HH:mm:ss.SSSZ). Use a dateFormat transform with outputFormat: 'ISO8601' if the source attribute is not already ISO8601. IGNORED if expression contains 'now'.",
+          "$ref": "#/$defs/NestedTransform"
         }
       }
     }
@@ -55,7 +53,7 @@
   "$defs": {
     "NestedTransform": {
       "type": "object",
-      "description": "Nested transform object used as explicit input. Docs examples frequently omit 'name' for nested transforms.",
+      "description": "A nested transform object whose output is the input datetime for this dateMath transform. Must produce an ISO8601 UTC string. Commonly wraps an accountAttribute through a dateFormat transform. The 'name' field is optional in nested transforms per SailPoint docs.",
       "additionalProperties": false,
       "required": [
         "type",
@@ -63,18 +61,22 @@
       ],
       "properties": {
         "id": {
-          "type": "string"
+          "type": "string",
+          "description": "Optional ID when referencing an existing saved transform."
         },
         "name": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "description": "Optional display name for the nested transform."
         },
         "type": {
           "type": "string",
-          "minLength": 1
+          "minLength": 1,
+          "description": "The operation type of the nested transform (e.g., 'dateFormat', 'accountAttribute')."
         },
         "requiresPeriodicRefresh": {
-          "type": "boolean"
+          "type": "boolean",
+          "description": "Whether this nested transform re-evaluates during nightly refresh."
         },
         "attributes": {
           "type": "object",
@@ -86,16 +88,33 @@
   },
   "examples": [
     {
+      "name": "Five Days Ago Rounded to Day",
       "type": "dateMath",
-      "name": "Date Math Transform",
+      "requiresPeriodicRefresh": true,
       "attributes": {
         "expression": "now-5d/d",
         "roundUp": false
       }
     },
     {
+      "name": "Current Time Rounded to Hour",
+      "type": "dateMath",
+      "requiresPeriodicRefresh": true,
+      "attributes": {
+        "expression": "now/h"
+      }
+    },
+    {
+      "name": "One Week From Now",
+      "type": "dateMath",
+      "requiresPeriodicRefresh": true,
+      "attributes": {
+        "expression": "now+1w"
+      }
+    },
+    {
+      "name": "Add 12 Hours to Source Date Rounded to Second",
       "type": "dateMath",
-      "name": "Date Math Transform (Explicit Input)",
       "attributes": {
         "expression": "+12h/s",
         "roundUp": true,
@@ -114,6 +133,14 @@
           }
         }
       }
+    },
+    {
+      "name": "Complex: Add 1 Year 1 Month 2 Days Minus 4 Hours Rounded to Second",
+      "type": "dateMath",
+      "requiresPeriodicRefresh": true,
+      "attributes": {
+        "expression": "now+1y+1M+2d-4h+1m-3s/s"
+      }
     }
   ]
 }

package/dist/transforms/lint.js

@@ -399,27 +399,34 @@ function lintReplaceAll(attrs) {
 function lintDateMath(attrs) {
     const msgs = [];
     const expr = attrs?.expression;
+    let startsWithNow = false;
+    let sawRound = false;
     if (expr !== undefined) {
         if (typeof expr !== "string" || expr.trim().length === 0) {
             push(msgs, "error", "expression must be a non-empty string.", "attributes.expression");
         }
         else {
             const s = expr.trim();
+            // --- No whitespace allowed ---
             if (/\s/.test(s)) {
                 push(msgs, "error", "expression must not contain whitespace.", "attributes.expression");
             }
+            // --- Valid character set: digits, y M w d h m s, n o w (for 'now'), +, -, / ---
             if (!/^[0-9yMwdhmsnow+\-/]+$/.test(s)) {
-                push(msgs, "error", "expression contains invalid characters. Allowed: digits, y M w d h m s, now, +, -, /.", "attributes.expression");
+                push(msgs, "error", "expression contains invalid characters. " +
+                    "Allowed units: y(year) M(month) w(week) d(day) h(hour) m(minute) s(second), keyword 'now', operators: + - /.", "attributes.expression");
             }
             let i = 0;
             const n = s.length;
-            const startsWithNow = s.startsWith("now");
+            startsWithNow = s.startsWith("now");
             if (startsWithNow)
                 i += 3;
+            // 'now' must only appear at the start
             if (!startsWithNow && s.includes("now")) {
-                push(msgs, "error", "'now' keyword must appear only at the start of the expression.", "attributes.expression");
+                push(msgs, "error", "'now' keyword must appear only at the start of the expression (e.g., 'now-5d/d', 'now+1w').", "attributes.expression");
             }
-            let sawOp = false, sawRound = false, roundUnit = null;
+            let sawOp = false;
+            let roundUnit = null;
             const readInt = () => {
                 const start = i;
                 while (i < n && /[0-9]/.test(s[i]))
@@ -438,19 +445,21 @@ function lintDateMath(attrs) {
             const readSignedTerm = (op) => {
                 const num = readInt();
                 if (!num) {
-                    push(msgs, "error", `Missing integer after '${op}' in expression.`, "attributes.expression");
+                    push(msgs, "error", `Missing integer after '${op}' in expression. Example: '${op}3d'.`, "attributes.expression");
                     return;
                 }
-                if (Number(num) === 0)
-                    push(msgs, "warn", `Term '${op}${num}' is a no-op (zero).`, "attributes.expression");
+                if (Number(num) === 0) {
+                    push(msgs, "warn", `Term '${op}${num}' adds/subtracts zero — this is a no-op.`, "attributes.expression");
+                }
                 const unit = readUnit();
-                if (!unit)
-                    push(msgs, "error", `Missing unit after '${op}${num}'. Allowed: y M w d h m s.`, "attributes.expression");
+                if (!unit) {
+                    push(msgs, "error", `Missing time unit after '${op}${num}'. Allowed units: y(year) M(month) w(week) d(day) h(hour) m(minute) s(second).`, "attributes.expression");
+                }
             };
             const readRound = () => {
                 const unit = readUnit();
                 if (!unit) {
-                    push(msgs, "error", "Rounding '/' must be followed by a unit (y M w d h m s).", "attributes.expression");
+                    push(msgs, "error", "Rounding operator '/' must be followed by a time unit. Allowed: y M d h m s (NOT w — week rounding is unsupported).", "attributes.expression");
                     return;
                 }
                 sawRound = true;
@@ -460,14 +469,14 @@ function lintDateMath(attrs) {
                 i++;
                 readRound();
                 if (i < n)
-                    push(msgs, "error", "Rounding must be the last part of the expression.", "attributes.expression");
+                    push(msgs, "error", "Rounding '/' must be the last segment of the expression (e.g., 'now-5d/d').", "attributes.expression");
             }
             else {
                 while (i < n) {
                     const ch = s[i];
                     if (ch === "+" || ch === "-") {
                         if (sawRound) {
-                            push(msgs, "error", "Add/subtract terms cannot appear after rounding ('/').", "attributes.expression");
+                            push(msgs, "error", "Add/subtract terms cannot appear after the rounding operator ('/').", "attributes.expression");
                             break;
                         }
                         sawOp = true;
@@ -477,43 +486,75 @@ function lintDateMath(attrs) {
                     }
                     if (ch === "/") {
                         if (sawRound) {
-                            push(msgs, "error", "Only one rounding operator '/' is supported.", "attributes.expression");
+                            push(msgs, "error", "Only one rounding operator '/' is allowed per expression.", "attributes.expression");
                             break;
                         }
                         i++;
                         readRound();
                         if (i < n)
-                            push(msgs, "error", "Rounding must be the last part of the expression.", "attributes.expression");
+                            push(msgs, "error", "Rounding '/' must be the last segment of the expression.", "attributes.expression");
                         break;
                     }
-                    push(msgs, "error", `Unexpected token '${ch}'. Use patterns like 'now-5d/d' or '+3M/h'.`, "attributes.expression");
+                    push(msgs, "error", `Unexpected token '${ch}' in expression '${s}'. ` +
+                        "Valid forms: 'now', 'now-5d/d', 'now+1y+1M', '+3M', '+12h/s'.", "attributes.expression");
                     break;
                 }
             }
+            // Expression must start with 'now', +, -, or /
             if (!startsWithNow && s !== "" && s[0] !== "+" && s[0] !== "-" && s[0] !== "/") {
-                push(msgs, "error", "Expression must start with 'now', '+', '-', or '/'.", "attributes.expression");
+                push(msgs, "error", `Expression must start with 'now', '+', '-', or '/'. Got: '${s}'. ` +
+                    "Examples: 'now-5d/d', '+3M', '-1y/d'.", "attributes.expression");
             }
-            // Week rounding not supported (SailPoint docs)
+            // Week rounding is explicitly unsupported per docs
             if (roundUnit === "w") {
-                push(msgs, "error", "Rounding with 'w' (week) is not supported in dateMath expressions.", "attributes.expression");
+                push(msgs, "error", "Rounding with 'w' (week) is not supported by SailPoint dateMath and will produce an error at runtime. " +
+                    "Use a different unit for rounding (y, M, d, h, m, s).", "attributes.expression");
             }
+            // Expression without 'now' and no ops is invalid
             if (!startsWithNow && !sawOp && !sawRound) {
-                push(msgs, "error", "Expression must contain 'now', at least one +/- term, or a rounding segment.", "attributes.expression");
+                push(msgs, "error", "Expression must contain 'now', at least one +/- term, or a rounding segment. " +
+                    "Examples: 'now', 'now-5d/d', '+3M/h'.", "attributes.expression");
             }
+            // Expression without 'now' requires an input date
             if (!startsWithNow && attrs?.input === undefined) {
-                push(msgs, "error", "dateMath expression without 'now' requires an input date transform in attributes.input.", "attributes.input");
+                push(msgs, "error", "dateMath expression without 'now' requires an explicit input date via attributes.input (nested transform). " +
+                    "The input must produce an ISO8601 UTC datetime. Use a dateFormat transform with outputFormat: 'ISO8601' if needed.", "attributes.input");
+            }
+            // Output format info — dateMath output is yyyy-MM-dd'T'HH:mm, not full ISO8601
+            push(msgs, "info", "dateMath output format is 'yyyy-MM-dd\\'T\\'HH:mm' — this is NOT full ISO8601. " +
+                "If this transform feeds into another transform that expects ISO8601 (e.g., dateCompare), " +
+                "wrap it with a dateFormat transform using outputFormat: 'ISO8601'.", "attributes.expression");
+            // Recommend requiresPeriodicRefresh when 'now' is used
+            if (startsWithNow) {
+                push(msgs, "info", "Expression uses 'now'. Set requiresPeriodicRefresh: true at the transform root level " +
+                    "so the date re-evaluates during nightly identity refresh — otherwise results may become stale.", "attributes.expression");
             }
         }
     }
+    // --- roundUp: boolean check ---
     if (attrs?.roundUp !== undefined && typeof attrs.roundUp !== "boolean") {
-        push(msgs, "error", "roundUp must be a boolean.", "attributes.roundUp");
+        push(msgs, "error", "roundUp must be a boolean. true = round up (truncate + add one unit); false = truncate only (default).", "attributes.roundUp");
     }
+    // --- roundUp without rounding operator has no effect ---
+    if (attrs?.roundUp === true &&
+        typeof expr === "string" &&
+        !expr.includes("/")) {
+        push(msgs, "warn", "roundUp is true but expression contains no rounding operator '/'. " +
+            "roundUp has no effect without '/'. Add a rounding segment (e.g., '/d') or remove roundUp.", "attributes.roundUp");
+    }
+    // --- input: must be a nested transform object ---
     if (attrs?.input !== undefined) {
         const inp = attrs.input;
         if (!(inp && typeof inp === "object" && typeof inp.type === "string")) {
-            push(msgs, "warn", "input should be a nested transform object {type, attributes}.", "attributes.input");
+            push(msgs, "warn", "input must be a nested transform object {type, attributes} that produces an ISO8601 UTC datetime. " +
+                "Use a dateFormat transform with outputFormat: 'ISO8601' if the source attribute is not already ISO8601.", "attributes.input");
         }
     }
+    // --- 'now' + input conflict warning ---
+    if (startsWithNow && attrs?.input !== undefined) {
+        push(msgs, "warn", "Expression uses 'now' and an input attribute is also provided. " +
+            "Per SailPoint docs, when 'now' is in the expression the transform ignores the input attribute entirely.", "attributes.input");
+    }
     return msgs;
 }
 // ---------------------------------------------------------------------------
@@ -618,7 +659,17 @@ function lintDateFormat(attrs) {
     const msgs = [];
     // Exact set of named formats per SailPoint docs — no variants accepted.
     const NAMED_FORMATS = new Set(["ISO8601", "LDAP", "PEOPLE_SOFT", "EPOCH_TIME_JAVA", "EPOCH_TIME_WIN32"]);
-    // A value that is ALL_CAPS_WITH_UNDERSCORES is clearly intended as a named constant, not a pattern.
+    // Human-readable descriptions for each named format (shown as info when used correctly)
+    const NAMED_FORMAT_DESCRIPTIONS = {
+        ISO8601: "yyyy-MM-dd'T'HH:mm:ss.SSSZ — ISO 8601 standard datetime",
+        LDAP: "yyyyMMddHHmmss.Z — LDAP directory format",
+        PEOPLE_SOFT: "MM/dd/yyyy — PeopleSoft system format",
+        EPOCH_TIME_JAVA: "milliseconds since Jan 1, 1970 (Java epoch) — input must be a numeric string",
+        EPOCH_TIME_WIN32: "100-nanosecond intervals since Jan 1, 1601 (Windows/Win32 epoch) — input must be a numeric string",
+    };
+    // ALL_CAPS_WITH_UNDERSCORES values are clearly intended as named constants, not patterns.
+    // Do NOT fall through to isLikelyPattern — e.g. EPOCH_TIME_JAVA_IN_MILLIS contains
+    // 'H' and 'M' and would falsely pass the pattern check.
     const looksLikeNamedConstant = (s) => /^[A-Z][A-Z0-9_]+$/.test(s);
     const isLikelyPattern = (s) => /[yMdHhmsSZ]/.test(s);
     const checkFmt = (field) => {
@@ -626,35 +677,59 @@ function lintDateFormat(attrs) {
         if (raw === undefined)
             return;
         if (typeof raw !== "string") {
-            push(msgs, "error", `${field} must be a string (named format or pattern).`, `attributes.${field}`);
+            push(msgs, "error", `${field} must be a string — either a named format (${Array.from(NAMED_FORMATS).join(", ")}) or a Java SimpleDateFormat pattern.`, `attributes.${field}`);
             return;
         }
         const t = raw.trim();
-        // If the value looks like a named constant (ALL_CAPS_UNDERSCORES), validate strictly.
-        // Do NOT fall through to isLikelyPattern — e.g. EPOCH_TIME_JAVA_IN_MILLIS contains
-        // 'H' and 'M' and would falsely pass the pattern check.
         if (looksLikeNamedConstant(t)) {
             if (!NAMED_FORMATS.has(t)) {
                 push(msgs, "error", `'${t}' is not a valid named format for ${field}. ` +
                     `Allowed named formats: ${Array.from(NAMED_FORMATS).join(", ")}. ` +
-                    `Alternatively, use a Java SimpleDateFormat pattern (e.g. dd-MM-yyyy, yyyy-MM-dd'T'HH:mm:ssZ).`, `attributes.${field}`);
+                    `Alternatively, use a Java SimpleDateFormat pattern (e.g. 'dd-MM-yyyy', 'yyyy-MM-dd\\'T\\'HH:mm:ssZ').`, `attributes.${field}`);
+            }
+            else {
+                push(msgs, "info", `${field} '${t}' → ${NAMED_FORMAT_DESCRIPTIONS[t]}.`, `attributes.${field}`);
             }
             return;
         }
-        // Value looks like a date pattern — check it has at least one date token.
+        // Value looks like a date pattern — check it has at least one recognisable date token.
         if (!isLikelyPattern(t)) {
-            push(msgs, "warn", `${field} '${t}' doesn't match a known named format and doesn't look like a date pattern (missing tokens like y/M/d/H).`, `attributes.${field}`);
+            push(msgs, "warn", `${field} '${t}' doesn't match a known named format and doesn't look like a Java SimpleDateFormat pattern ` +
+                "(expected tokens like y, M, d, H, h, m, s, S, Z). " +
+                `Valid named formats: ${Array.from(NAMED_FORMATS).join(", ")}.`, `attributes.${field}`);
         }
     };
     checkFmt("inputFormat");
     checkFmt("outputFormat");
+    // --- EPOCH format input reminders ---
+    const inFmt = attrs?.inputFormat;
+    if (typeof inFmt === "string" && (inFmt === "EPOCH_TIME_JAVA" || inFmt === "EPOCH_TIME_WIN32")) {
+        push(msgs, "info", `inputFormat '${inFmt}' expects a numeric string as input — ` +
+            (inFmt === "EPOCH_TIME_JAVA"
+                ? "milliseconds since Jan 1, 1970 (e.g., '1609459200000')."
+                : "100-nanosecond intervals since Jan 1, 1601 (Windows FILETIME)."), "attributes.inputFormat");
+    }
+    // --- input: validate type, reject 'now', guide on valid forms ---
     if (attrs?.input !== undefined) {
         const inp = attrs.input;
-        if (typeof inp === "object" && inp !== null && typeof inp.type !== "string") {
-            push(msgs, "warn", "input looks like an object but is missing a nested transform 'type'.", "attributes.input");
+        if (typeof inp === "string") {
+            // 'now' is explicitly NOT supported by dateFormat per official docs
+            if (inp.trim().toLowerCase() === "now") {
+                push(msgs, "error", "dateFormat does not support 'now' as an input value (official docs limitation). " +
+                    "To derive a date from the current time, use a dateMath transform producing an ISO8601 string " +
+                    "and reference it as a nested transform in the input field.", "attributes.input");
+            }
+            // A static date string is valid — no further warning needed
         }
-        else if (typeof inp !== "string" && !isPlainObject(inp)) {
-            push(msgs, "warn", "input should be a string or a nested transform object.", "attributes.input");
+        else if (isPlainObject(inp)) {
+            if (typeof inp.type !== "string") {
+                push(msgs, "warn", "input is an object but is missing a 'type' field — it does not look like a valid nested transform. " +
+                    "Add a 'type' (e.g., 'accountAttribute', 'dateMath') to make it a proper nested transform.", "attributes.input");
+            }
+            // Otherwise it's a well-formed nested transform — no warning
+        }
+        else {
+            push(msgs, "warn", "input should be a static date string matching inputFormat, or a nested transform object {type, attributes}.", "attributes.input");
         }
     }
     return msgs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isc-transforms-mcp",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "type": "module",
   "description": "MCP server for SailPoint Identity Security Cloud (ISC) Transform authoring — scaffold, strict lint, catalog, and safe upsert to live tenants.",
   "author": {