@celigo/api-specs 0.2.162 → 0.2.164

package/dist/import.yml

@@ -1978,6 +1978,12 @@ components:
               Avoid bare ``{{{jsonSerialize record}}}`` with no wrapper — leave the field undefined instead.
               Also avoid wrapping a single post-mapped scalar field in ``jsonSerialize`` (e.g.
               ``{{{jsonSerialize record.<scalar>}}}``) — that pattern is brittle.
+            - |-
+              In a JSON body, write a string value with double braces inside the quotes
+              (``"{{record.name}}"``): double braces JSON-escape the value at run time, with no HTML
+              escaping. Triple braces insert the raw text, so a value holding a double quote,
+              backslash, newline or tab fails that record with 422 ``invalid_json`` before anything
+              is sent.
             - |-
               Every request context carries two data roots: ``data`` — the list of records in
               the request, always present (Pattern B) — and ONE shape-specific root that follows
@@ -2107,10 +2113,12 @@ components:
               is almost certainly the "leave body undefined" case (the
               destination just wants the mapped record as JSON) or Pattern C
               (use ``{{sku}}`` / ``{{quantity}}`` directly without
-              ``jsonSerialize`` inside a per-message envelope).  Plain
-              ``{{{record.<field>}}}`` WITHOUT ``jsonSerialize`` is fine for
-              embedding a scalar into a string literal; the anti-pattern is
-              specifically the ``jsonSerialize`` wrap.
+              ``jsonSerialize`` inside a per-message envelope).  To embed a
+              scalar in a JSON string literal, use double braces inside the
+              quotes (``"{{record.<field>}}"``) WITHOUT ``jsonSerialize``;
+              triple braces there fail on a quote, backslash, newline or tab
+              in the value. The anti-pattern is specifically the
+              ``jsonSerialize`` wrap.
             - |-
               ## Multipart/form-data uploads are a different body contract
 
@@ -5188,8 +5196,10 @@ components:
                   `extract` to pick the column when the query returns multiple.
                   Inject values from the incoming record with Handlebars and the
                   `record.` prefix — double braces for strings, which the platform
-                  quotes and escapes, and triple braces for numbers:
-                  `SELECT id FROM users WHERE email = {{record.email}}`.
+                  quotes, escaping their apostrophes, and triple braces for numbers:
+                  `SELECT id FROM users WHERE email = {{record.email}}`. On Snowflake
+                  the quoting leaves backslashes, which Snowflake reads as escape
+                  sequences (see `query`).
               extract:
                 type: string
                 description: |
@@ -5237,10 +5247,11 @@ components:
           description: |-
             SQL statements to execute; required when queryType is `["per_record"]`, `["per_page"]`, or `["first_page"]`, and typically contains a single statement.
             Each element is a complete SQL statement as a plain string — never a single bare string and never an array of objects (objects cause a Cast error).
-            Inject values from the incoming record with Handlebars using the `record.` prefix: double braces for strings and dates (`{{record.name}}`; the platform quotes and escapes the value) and triple braces for numbers (`{{{record.quantity}}}`).
+            Inject values from the incoming record with Handlebars using the `record.` prefix: double braces for strings and dates (`{{record.name}}`; the platform quotes the value and escapes its apostrophes) and triple braces for numbers (`{{{record.quantity}}}`).
             Rendering is strict: a reference the render model cannot resolve (a bare `{{name}}` without prefix, or `record.*` when the arriving record is a grouped array) fails the step with `cannot_evaluate_handlebars` — it does not render an empty value.
             `record` and `rows` are aliases chosen by the arriving data's shape: an object record binds `record` (`rows` undefined); a grouped array-record (e.g. upstream `groupByFields`) binds `rows` (`record` undefined) — address grouped rows as `{{rows.0.field}}` or iterate `{{#each rows}}`.
-            Double braces (`{{record.field}}`) output the value wrapped in single quotes with embedded quotes doubled, while triple braces output it raw; block helpers such as `{{#each}}` and `{{#if}}` use double braces as normal.
+            Double braces (`{{record.field}}`) output a string value wrapped in single quotes with embedded quotes doubled, while triple braces output it raw; block helpers such as `{{#each}}` and `{{#if}}` use double braces as normal. In Snowflake queries a JSON number or boolean renders bare under double braces too (observed in export queries).
+            On Snowflake, the quoting leaves backslashes, which Snowflake reads as escape sequences: a double-brace value holding a backslash arrives changed, and `PARSE_JSON({{jsonSerialize …}})` fails on a double quote or line break in the data (observed in export queries). Pass such values in a dollar-quoted constant with triple braces (`$${{{record.field}}}$$`), which Snowflake reads as is, but only when the value can't contain `$$`: a `$$` in it ends the constant, and the rest is read as SQL.
           x-celigo-ai-guidance:
             - |-
               Use Handlebars to inject values from incoming records.
@@ -5268,14 +5279,18 @@ components:
               - **Double-brace `{{record.field}}` vs. triple-brace `{{{record.field}}}`
                 is a QUOTING CHOICE, not a syntax rule.** In RDBMS context the
                 platform's Handlebars renderer treats double-brace specially: it
-                auto-wraps the value as a SQL string literal (single-quoted, with
-                embedded quotes escaped).  Triple-brace emits the raw value with
-                no quoting.
+                wraps a string value as a SQL string literal (single-quoted, with
+                its apostrophes escaped), and in Snowflake export queries a number
+                or boolean rendered bare, whether a JSON value or a numeric
+                helper's result (`{{add 2 3}}`). Triple-brace emits the raw value
+                with no quoting. In the same queries the wrapping was also seen on
+                string helper output (`dateFormat`, `jsonSerialize`) and on
+                `{{this}}` inside `{{#each}}`.
 
                 - `{{record.name}}`    →  `'Alice'` (auto-single-quoted, embedded `'` doubled to `''`)
-                - `{{{record.name}}}`  →  `Alice`   (raw, no quoting — you must add your own)
-                - `{{record.qty}}`     →  `'5'`     (numbers are also string-wrapped under double-brace)
-                - `{{{record.qty}}}`   →  `5`       (numeric literal — what you usually want for INT columns)
+                - `{{{record.name}}}`  →  `Alice`   (raw — never wrap it in single quotes of your own: the first apostrophe in the data ends the literal)
+                - `{{record.qty}}`     →  `'5'` when `qty` arrives as the string `"5"`; a JSON number rendered bare in Snowflake export queries
+                - `{{{record.qty}}}`   →  `5`       (numeric literal either way — what you usually want for INT columns)
 
                 Pick by what the SQL needs at that slot:
 
@@ -5285,8 +5300,21 @@ components:
                 | Numeric column value (INT, DECIMAL, ...) | `{{{record.field}}}`    |
                 | Stored procedure raw arg (already typed) | `{{{record.field}}}`    |
                 | Identifier (table/column name)           | `{{{record.field}}}`    |
-                | JSON literal (`PARSE_JSON`/JSONB)      | `{{jsonSerialize record.subobject}}` (renders the JSON as a quoted string) |
-
+                | JSON literal, Snowflake (`PARSE_JSON`)   | `PARSE_JSON($${{{jsonSerialize record.subobject}}}$$)` (a dollar-quoted constant, read as is; only for data that can't contain `$$`, which ends it) |
+                | JSON literal, PostgreSQL (`JSONB`)       | `{{jsonSerialize record.subobject}}` (renders the JSON as a quoted string; not yet verified on PostgreSQL) |
+
+              - **Snowflake reads backslashes as escapes.** The double-brace
+                quoting doubles embedded apostrophes but leaves backslashes, and
+                Snowflake interprets backslash sequences inside a single-quoted
+                literal: a value holding `C:\temp` arrives with a tab in it, with
+                no error, and `PARSE_JSON({{jsonSerialize …}})` fails with
+                `Error parsing JSON` whenever a string in the object holds a double
+                quote or a line break, because `jsonSerialize` escapes those with
+                backslashes (observed in export queries). For values that can hold
+                these characters, use a dollar-quoted constant with triple braces
+                (`$${{{record.field}}}$$`), which Snowflake reads as is, but only
+                when the value can't contain `$$`: a `$$` in it ends the constant,
+                and the rest is read as SQL.
               - **Block helpers** (`{{#each}}`, `{{#if}}`, `{{/each}}`,
                 `{{#unless}}`) use double braces as normal — they emit no value.
               - **Nested fields**: `{{record.properties.email}}` (auto-quoted)
@@ -5300,7 +5328,7 @@ components:
               - UPSERT (MySQL): `["INSERT INTO users (id, name) VALUES ({{{record.id}}}, {{record.name}}) ON DUPLICATE KEY UPDATE name = {{record.name}}"]`
               - MERGE (Snowflake): `["MERGE INTO target USING (SELECT {{record.email}} AS email) AS src ON target.email = src.email WHEN MATCHED THEN UPDATE SET name = {{record.name}}"]`
               - Stored procedure (raw args): `["call netsuite.transformation_data_import({{record.record_type}}, 20)"]`
-              - JSON literal column (Snowflake VARIANT): `["INSERT INTO events (payload) SELECT PARSE_JSON({{jsonSerialize record.financialEvents}})"]`
+              - JSON literal column (Snowflake VARIANT; the data must not contain `$$`): `["INSERT INTO events (payload) SELECT PARSE_JSON($${{{jsonSerialize record.financialEvents}}}$$)"]`
               - Per-page batch (different Handlebars context — see `queryType: per_page` below): `["{{#each batch_of_records}}UPDATE staging SET done=1 WHERE id={{{this.record.id}}};{{/each}}"]`
           examples:
             - - INSERT INTO orders (id, total) VALUES ({{{record.id}}}, {{{record.total}}})
@@ -9681,7 +9709,7 @@ components:
                           description: Property names the model must include in the structured output.
                           items:
                             type: string
-                        additionalproperties:
+                        additionalProperties:
                           type: boolean
                           description: When true, the structured output may include properties beyond those defined in `properties`.
                     schema:
@@ -11072,7 +11100,7 @@ components:
                           description: Property names the stored JSON Schema marks as required.
                           items:
                             type: string
-                        additionalproperties:
+                        additionalProperties:
                           type: boolean
                           description: Whether the stored JSON Schema allows properties beyond those in `properties`.
                     schema:
@@ -12655,7 +12683,8 @@ components:
             fields. There is no separate `date` enum value.
 
             **Complex Types (require additional configuration)**
-            - `object`: Creates a nested object. REQUIRES child mappings in the 'mappings' array
+            - `object`: Creates a nested object from child mappings in the 'mappings' array, or
+              copies a whole object with `extract` (one or the other, not both)
 
             **Array Types**
             - `stringarray`: Array of strings
@@ -12703,7 +12732,7 @@ components:
             string: Text values; converts other types to their string representation.
             number: Numeric values; attempts conversion from strings.
             boolean: True/false values; converts truthy/falsy values.
-            object: Nested object that requires child mappings in the `mappings` array.
+            object: Nested object built from child `mappings`, or copied whole with `extract` (not both).
             stringarray: Array of string values.
             numberarray: Array of numeric values.
             booleanarray: Array of boolean values.
@@ -12781,7 +12810,10 @@ components:
             - JSON path patterns ALWAYS execute from the TOP-LEVEL root of the input record
             - The system maintains this context even in deeply nested mappings
             - For object mappings without child mappings, extract should return a complete object
-            - When both extract and mappings are defined for objects, extract is applied first
+            - An `object` row takes `extract` (to copy a whole object) or child `mappings`, not
+              both: a row with both fails with 422 (`"extract" should not be present if
+              "mappings" field is present`). A `buildArrayHelper` entry is different: there
+              `extract` and `mappings` work together.
             - The root is the record as it arrives: an object record roots at `$.field`; a
               grouped record (an array of rows — grouped exports, file key columns, NetSuite
               grouped saved searches) roots at the array, so its rows are addressed as
@@ -13735,7 +13767,8 @@ components:
               fields. There is no separate `date` enum value.
 
               **Complex Types (require additional configuration)**
-              - `object`: Creates a nested object. REQUIRES child mappings in the 'mappings' array
+              - `object`: Creates a nested object from child mappings in the 'mappings' array, or
+                copies a whole object with `extract` (one or the other, not both)
 
               **Array Types**
               - `stringarray`: Array of strings
@@ -13783,7 +13816,7 @@ components:
               string: Text values; converts other types to their string representation.
               number: Numeric values; attempts conversion from strings.
               boolean: True/false values; converts truthy/falsy values.
-              object: Nested object that requires child mappings in the `mappings` array.
+              object: Nested object built from child `mappings`, or copied whole with `extract` (not both).
               stringarray: Array of string values.
               numberarray: Array of numeric values.
               booleanarray: Array of boolean values.
@@ -13861,7 +13894,10 @@ components:
               - JSON path patterns ALWAYS execute from the TOP-LEVEL root of the input record
               - The system maintains this context even in deeply nested mappings
               - For object mappings without child mappings, extract should return a complete object
-              - When both extract and mappings are defined for objects, extract is applied first
+              - An `object` row takes `extract` (to copy a whole object) or child `mappings`, not
+                both: a row with both fails with 422 (`"extract" should not be present if
+                "mappings" field is present`). A `buildArrayHelper` entry is different: there
+                `extract` and `mappings` work together.
               - The root is the record as it arrives: an object record roots at `$.field`; a
                 grouped record (an array of rows — grouped exports, file key columns, NetSuite
                 grouped saved searches) roots at the array, so its rows are addressed as
@@ -15000,10 +15036,11 @@ components:
                       ALWAYS reference the `record` root regardless of
                       `inputContext` — only JSONPath anchoring flips.
                     - |-
-                      In `envelope` mode a `modify` transform merges its mapped
-                      fields into `record` and keeps the rest of the envelope
-                      around it; a `create` transform returns only the mapped
-                      fields, as a bare record.
+                      In `envelope` mode the output is still a bare record: a
+                      `modify` transform returns the record with its mapped
+                      fields merged in (no `record` wrapper, no `job` or
+                      `settings` keys), and a `create` transform returns only
+                      the mapped fields.
                     - |-
                       Emit `inputContext` explicitly on new v2 transforms:
                       unset is read as `record`, but stating it makes the
@@ -15183,13 +15220,14 @@ components:
           type: string
           description: |
             Source expression. Accepts:
-            - JSONPath starting with `$.` (e.g. `$.customer.firstName`).
+            - A dot path from the record root (e.g. `email`, `address.city`), read from the
+              incoming record. A path that matches no field writes nothing.
             - Handlebars template (contains `{{`) for concatenation /
               formatting / conditional logic (e.g.
               `{{record.firstName}} {{record.lastName}}`).
-            - A literal string (any value not starting with `$.` and not
-              containing `{{`) — treated as a hardcoded value.
 
+            A `$.` JSONPath (the Mapper 2.0 `mappings` syntax) reads nothing here, and a bare
+            string is read as a field path, not a constant: set constants in `hardCodedValue`.
             Omit when using `hardCodedValue`.
           examples:
             - address.city
@@ -15200,9 +15238,9 @@ components:
           description: Static value written to `generate` instead of extracting from the source record.
           x-celigo-ai-guidance:
             - |-
-              Static value written verbatim. Equivalent to setting ``extract``
-              to a literal string; choose whichever reads more clearly. Mutually
-              exclusive with ``extract``.
+              Static value written verbatim. Use it for every constant: a bare
+              string in ``extract`` is read as a field path. Mutually exclusive
+              with ``extract``.
         dataType:
           type: string
           enum:
@@ -15965,7 +16003,10 @@ components:
           type: string
           format: objectId
           x-celigo-refModel: connectors
-          description: Connector this import was created from, set when the import is part of an installed integration app.
+          description: |-
+            Connector this import was created from, set when the import is part of an installed
+            integration app. The app's install sets it: a create that sends it is refused with 403
+            ("Cannot create an Integration App resource").
           examples:
             - 60a2c4e6f321d800129a1a3c
         adaptorType:
@@ -16507,7 +16548,8 @@ components:
           description: |-
             Custom JavaScript hooks that run at fixed points in the import lifecycle for
             transformations, validation, and custom result handling beyond what configuration alone
-            can express.
+            can express. A hook name not listed here (an export's `preSavePage`, for example) is
+            dropped on save without an error, so read `hooks` back after saving.
           x-celigo-ai-guidance:
             - |-
               JavaScript hook references attached to lifecycle stages of the import.

package/dist/script.yml

@@ -376,7 +376,8 @@ paths:
         `nextPageURL` means that slice held nothing while the rest of the window is still
         unread — follow the cursor until a response arrives without one. Only an empty
         `logs` array with no `nextPageURL` means the window holds no entries. To read a
-        known run in one call, set `time_lte` a few seconds after the run ended.
+        known run in one call, set `time_lte` a few seconds after the run ended and
+        `time_gt` just before it started (`time_lte` needs `time_gt`).
       tags:
         - Scripts
       operationId: getScriptLogs
@@ -394,7 +395,8 @@ paths:
           required: false
           description: |-
             Upper bound of the time window (inclusive), as epoch milliseconds. Defaults to now if
-            omitted. Reading starts here and proceeds backward.
+            omitted. Reading starts here and proceeds backward. Send it with `time_gt`: `time_lte`
+            alone fails with 422 ("Invalid or Missing Field: time_gt").
           schema:
             type: integer
             format: int64
@@ -513,6 +515,17 @@ paths:
           $ref: '#/components/responses/401-unauthorized'
         '404':
           $ref: '#/components/responses/404-not-found'
+        '422':
+          description: Invalid time window — `time_lte` without `time_gt`.
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+              examples:
+                missing_time_gt:
+                  value:
+                    errors:
+                      - message: 'Invalid or Missing Field: time_gt'
     delete:
       x-internal: false
       operationId: deleteScriptLogs