@wix/motion-edm-autogen-transformations-core 1.3.0

package/dist/cjs/__tests__/validations/validateResponseTransformation.spec.js

@@ -0,0 +1,370 @@
+"use strict";
+
+var _motionRuntimeTestContext = require("@wix/motion-runtime-test-context");
+
+var _lodash = require("lodash");
+
+var _ = require("../..");
+
+const validateResponseTransformation = _.validation.validateResponseTransformation;
+describe('validateResponseTransformation', () => {
+  describe('valid transformations', () => {
+    const validResults = {
+      isValid: true,
+      validationErrors: []
+    };
+    test('returns valid transformation response for a valid simple transformation', () => {
+      const validTransformation = '$.a.b.c';
+      expect(validateResponseTransformation(validTransformation)).toStrictEqual(validResults);
+    });
+    test('returns valid transformation response for a valid complex transformation', () => {
+      const validTransformation = {
+        aaa: '$.a.b.c'
+      };
+      expect(validateResponseTransformation(validTransformation)).toStrictEqual(validResults);
+    });
+  });
+  describe('invalid transformations', () => {
+    const parentKey = (0, _motionRuntimeTestContext.aString)();
+
+    const validationErrorWith = ({
+      parentPath,
+      invalidValue,
+      description
+    }) => ({
+      isValid: false,
+      validationErrors: expect.arrayContaining([expect.objectContaining({
+        parentPath,
+        invalidValue,
+        description
+      })])
+    });
+
+    describe('invalid simple transformations', () => {
+      test('returns a validation error when the transformation starts with an index argument', () => {
+        const transformation = '$[0].a.b.c';
+        expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+          parentPath: null,
+          invalidValue: transformation,
+          description: "must be a string starting with '$.'"
+        }));
+      });
+    });
+    describe('invalid complex-transformation keys', () => {
+      test.each`
+        description                        | transformationKey  | expectedValidationMessage
+        ${'refers to an argument index'}   | ${'$[0]'}          | ${"must be a string starting with '$.'"}
+        ${'refers to the root identifier'} | ${'$'}             | ${'cannot refer to $ in a transformation key'}
+        ${'refers to a custom function'}   | ${'#someFunction'} | ${'cannot be a custom function call'}
+      `('returns a validation error when a transformation value segment $description', ({
+        transformationKey,
+        expectedValidationMessage
+      }) => {
+        const transformation = {
+          d: {
+            e: {
+              f: {
+                [transformationKey]: '$.a.b.c'
+              }
+            }
+          },
+          '*': '$[1]'
+        };
+        expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+          parentPath: 'd.e.f',
+          invalidValue: transformationKey,
+          description: expectedValidationMessage
+        }));
+      });
+    });
+    describe('invalid transformations values', () => {
+      describe('custom function expressions', () => {
+        const invalidCustomFunctionName = '#1a';
+        describe('invalid custom function-name is used', () => {
+          test.each`
+            description    | transformation                                    | expectedParentPath
+            ${'top level'} | ${invalidCustomFunctionName}                      | ${null}
+            ${'nested'}    | ${{
+            a: {
+              b: {
+                c: invalidCustomFunctionName
+              }
+            }
+          }} | ${'a.b.c'}
+          `('returns a validation error for $description cases', ({
+            expectedParentPath,
+            transformation
+          }) => {
+            expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: invalidCustomFunctionName,
+              description: 'contains an invalid custom function expression'
+            }));
+          });
+        });
+        describe('a custom function argument is invalid in response transformation', () => {
+          const invalidCustomFunctionExpression = '#someFunction($[0])';
+          test.each`
+            description    | transformation                                          | expectedParentPath
+            ${'top level'} | ${invalidCustomFunctionExpression}                      | ${null}
+            ${'nested'}    | ${{
+            a: {
+              b: {
+                c: invalidCustomFunctionExpression
+              }
+            }
+          }} | ${'a.b.c'}
+          `('returns a validation error for $description cases', ({
+            expectedParentPath,
+            transformation
+          }) => {
+            expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: '$[0]',
+              description: "must be a string starting with '$.'"
+            }));
+          });
+        });
+        test('returns a validation error when an argument index is used', () => {
+          const argumentExpression = '$[1].a.b.c.';
+          const path = 'd.e.f';
+          const transformation = (0, _lodash.set)({}, path, argumentExpression);
+          expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+            parentPath: path,
+            invalidValue: argumentExpression,
+            description: "must be a string starting with '$.'"
+          }));
+        });
+      });
+      describe.each`
+        description                  | transformationValue | expectedValidationMessage
+        ${'does not start with $'}   | ${'a.b.c'}          | ${"must be a string starting with '$.'"}
+        ${'refers to * in the path'} | ${'$.a.b.*'}        | ${'cannot refer to the * operator'}
+      `('returns a validation error when a transformation value segment $description', ({
+        transformationValue,
+        expectedValidationMessage
+      }) => {
+        test('simple transformation', () => {
+          expect(validateResponseTransformation(transformationValue)).toStrictEqual(validationErrorWith({
+            parentPath: null,
+            invalidValue: transformationValue,
+            description: expectedValidationMessage
+          }));
+        });
+        test('complex transformation', () => {
+          const transformation = {
+            d: {
+              e: {
+                f: transformationValue
+              }
+            }
+          };
+          expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+            parentPath: 'd.e.f',
+            invalidValue: transformationValue,
+            description: expectedValidationMessage
+          }));
+        });
+      });
+      describe('special fields', () => {
+        describe.each(['_id', '_createdDate', '_updatedDate'])('%s', specialField => {
+          const expectedValidationMessage = `cannot refer to the ${specialField} field`;
+          test('returns a validation error when a transformation value segment $description', () => {
+            const transformation = {
+              d: {
+                e: {
+                  f: {
+                    [specialField]: '$.a.b.c'
+                  }
+                }
+              },
+              '*': '$[1]'
+            };
+            expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: 'd.e.f',
+              invalidValue: specialField,
+              description: expectedValidationMessage
+            }));
+          });
+          describe('simple transformation', () => {
+            test(`returns a validation error when a segment refers to the special field ${specialField}`, () => {
+              const transformationValue = `$.a.b.${specialField}`;
+              expect(validateResponseTransformation(transformationValue)).toStrictEqual(validationErrorWith({
+                parentPath: null,
+                invalidValue: transformationValue,
+                description: expectedValidationMessage
+              }));
+            });
+          });
+          test('complex transformation', () => {
+            const transformationValue = `$.a.b.${specialField}`;
+            const transformation = {
+              d: {
+                e: {
+                  f: transformationValue
+                }
+              }
+            };
+            expect(validateResponseTransformation(transformation)).toStrictEqual(validationErrorWith({
+              parentPath: 'd.e.f',
+              invalidValue: transformationValue,
+              description: expectedValidationMessage
+            }));
+          });
+        });
+      });
+    });
+    describe('omit transformation', () => {
+      describe('invalid @source', () => {
+        const invalidSourceValue = 'a.b.c';
+        const invalidSourceTransformation = {
+          '@source': invalidSourceValue,
+          '@omit': (0, _lodash.times)(2, () => (0, _motionRuntimeTestContext.aString)())
+        };
+        test.each`
+          description    | invalidTransformation                           | expectedParentPath
+          ${'top level'} | ${invalidSourceTransformation}                  | ${'@source'}
+          ${'nested'}    | ${{
+          [parentKey]: invalidSourceTransformation
+        }} | ${`${parentKey}.@source`}
+        `('returns a validation error when the @source value is invalid', ({
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+            parentPath: expectedParentPath,
+            invalidValue: invalidSourceValue,
+            description: "must be a string starting with '$.'"
+          }));
+        });
+      });
+      describe('invalid @omit', () => {
+        const transformationWithOmitValue = value => ({
+          '@source': '$.a.b.c',
+          '@omit': value
+        });
+
+        const nonArray = (0, _motionRuntimeTestContext.aString)();
+        const nonStringArray = (0, _lodash.times)(2, () => (0, _motionRuntimeTestContext.aNumber)());
+        const arrayWithInvalidPaths = ['a.b.c', (0, _motionRuntimeTestContext.aString)()];
+        describe.each`
+          description    | invalidTransformation                                     | expectedParentPath
+          ${'top level'} | ${transformationWithOmitValue(nonArray)}                  | ${'@omit'}
+          ${'nested'}    | ${{
+          [parentKey]: transformationWithOmitValue(nonArray)
+        }} | ${`${parentKey}.@omit`}
+        `('@omit is not an array', ({
+          description,
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          test(`returns a validation error for invalid ${description} transformation`, () => {
+            expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: nonArray,
+              description: 'must be an array of strings'
+            }));
+          });
+        });
+        describe.each`
+          description    | invalidTransformation                                           | expectedParentPath
+          ${'top level'} | ${transformationWithOmitValue(nonStringArray)}                  | ${'@omit'}
+          ${'nested'}    | ${{
+          [parentKey]: transformationWithOmitValue(nonStringArray)
+        }} | ${`${parentKey}.@omit`}
+        `('@omit is an array of non-strings', ({
+          description,
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          test(`returns a validation error for invalid ${description} transformation`, () => {
+            expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: nonStringArray,
+              description: 'must be an array of strings'
+            }));
+          });
+        });
+        /* eslint-disable max-len */
+
+        describe.each`
+          description    | invalidTransformation                                                  | expectedParentPath
+          ${'top level'} | ${transformationWithOmitValue(arrayWithInvalidPaths)}                  | ${'@omit'}
+          ${'nested'}    | ${{
+          [parentKey]: transformationWithOmitValue(arrayWithInvalidPaths)
+        }} | ${`${parentKey}.@omit`}
+        `('@omit is an array of invalid string paths', ({
+          description,
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          /* eslint-enable max-len */
+          test(`returns a validation error for invalid ${description} transformation`, () => {
+            expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+              parentPath: expectedParentPath,
+              invalidValue: arrayWithInvalidPaths,
+              description: 'must contain non-nested paths only'
+            }));
+          });
+        });
+      });
+    });
+    describe('array-item transformation', () => {
+      const validValue = '$.d.e.f';
+
+      const invalidPathTransformationWith = invalidPathValue => ({
+        '@path': invalidPathValue,
+        '@itemTransformation': validValue
+      });
+
+      describe.each`
+        invalidValue                                            | description
+        ${'$[0].should.fail'}                                   | ${'invalid path value'}
+        ${(0, _motionRuntimeTestContext.aRandomItemFrom)([(0, _motionRuntimeTestContext.aBoolean)(), (0, _motionRuntimeTestContext.aNumber)(), (0, _motionRuntimeTestContext.anObject)()])} | ${'invalid path type'}
+      `('$description', ({
+        invalidValue
+      }) => {
+        test.each`
+          description    | invalidTransformation                                           | expectedParentPath
+          ${'top-level'} | ${invalidPathTransformationWith(invalidValue)}                  | ${'@path'}
+          ${'nested'}    | ${{
+          [parentKey]: invalidPathTransformationWith(invalidValue)
+        }} | ${`${parentKey}.@path`}
+        `('returns a validation error when the @path value is invalid for $description transformation', ({
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+            parentPath: expectedParentPath,
+            invalidValue,
+            description: "must be a string starting with '$.'"
+          }));
+        });
+      });
+      describe('invalid @itemTransformation', () => {
+        const invalidValue = '$[0].should.fail';
+        const invalidPathTransformation = {
+          '@path': validValue,
+          '@itemTransformation': invalidValue
+        };
+        test.each`
+          description    | invalidTransformation                         | expectedParentPath
+          ${'top-level'} | ${invalidPathTransformation}                  | ${'@itemTransformation'}
+          ${'nested'}    | ${{
+          [parentKey]: invalidPathTransformation
+        }} | ${`${parentKey}.@itemTransformation`}
+        `('returns a validation error when the @itemTransformation value is invalid for $description transformation', ({
+          invalidTransformation,
+          expectedParentPath
+        }) => {
+          expect(validateResponseTransformation(invalidTransformation)).toStrictEqual(validationErrorWith({
+            parentPath: expectedParentPath,
+            invalidValue,
+            description: "must be a string starting with '$.'"
+          }));
+        });
+      });
+    });
+  });
+});
+//# sourceMappingURL=validateResponseTransformation.spec.js.map

package/dist/cjs/__tests__/validations/validateResponseTransformation.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/__tests__/validations/validateResponseTransformation.spec.ts"],"names":["validateResponseTransformation","validation","describe","validResults","isValid","validationErrors","test","validTransformation","expect","toStrictEqual","aaa","parentKey","validationErrorWith","parentPath","invalidValue","description","arrayContaining","objectContaining","transformation","each","transformationKey","expectedValidationMessage","d","e","f","invalidCustomFunctionName","a","b","c","expectedParentPath","invalidCustomFunctionExpression","argumentExpression","path","transformationValue","specialField","invalidSourceValue","invalidSourceTransformation","invalidTransformation","transformationWithOmitValue","value","nonArray","nonStringArray","arrayWithInvalidPaths","validValue","invalidPathTransformationWith","invalidPathValue","invalidPathTransformation"],"mappings":"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","sourcesContent":["import {\n  aString,\n  aNumber,\n  aRandomItemFrom,\n  aBoolean,\n  anObject,\n} from '@wix/motion-runtime-test-context';\nimport { set, times } from 'lodash';\nimport { validation } from '../..';\n\nconst { validateResponseTransformation } = validation;\n\ndescribe('validateResponseTransformation', () => {\n  describe('valid transformations', () => {\n    const validResults = { isValid: true, validationErrors: [] };\n\n    test('returns valid transformation response for a valid simple transformation', () => {\n      const validTransformation = '$.a.b.c';\n\n      expect(validateResponseTransformation(validTransformation)).toStrictEqual(\n        validResults,\n      );\n    });\n\n    test('returns valid transformation response for a valid complex transformation', () => {\n      const validTransformation = { aaa: '$.a.b.c' };\n\n      expect(validateResponseTransformation(validTransformation)).toStrictEqual(\n        validResults,\n      );\n    });\n  });\n\n  describe('invalid transformations', () => {\n    const parentKey = aString();\n\n    const validationErrorWith = ({\n      parentPath,\n      invalidValue,\n      description,\n    }) => ({\n      isValid: false,\n      validationErrors: expect.arrayContaining([\n        expect.objectContaining({\n          parentPath,\n          invalidValue,\n          description,\n        }),\n      ]),\n    });\n\n    describe('invalid simple transformations', () => {\n      test('returns a validation error when the transformation starts with an index argument', () => {\n        const transformation = '$[0].a.b.c';\n\n        expect(validateResponseTransformation(transformation)).toStrictEqual(\n          validationErrorWith({\n            parentPath: null,\n            invalidValue: transformation,\n            description: \"must be a string starting with '$.'\",\n          }),\n        );\n      });\n    });\n\n    describe('invalid complex-transformation keys', () => {\n      test.each`\n        description                        | transformationKey  | expectedValidationMessage\n        ${'refers to an argument index'}   | ${'$[0]'}          | ${\"must be a string starting with '$.'\"}\n        ${'refers to the root identifier'} | ${'$'}             | ${'cannot refer to $ in a transformation key'}\n        ${'refers to a custom function'}   | ${'#someFunction'} | ${'cannot be a custom function call'}\n      `(\n        'returns a validation error when a transformation value segment $description',\n        ({ transformationKey, expectedValidationMessage }) => {\n          const transformation = {\n            d: { e: { f: { [transformationKey]: '$.a.b.c' } } },\n            '*': '$[1]',\n          };\n\n          expect(validateResponseTransformation(transformation)).toStrictEqual(\n            validationErrorWith({\n              parentPath: 'd.e.f',\n              invalidValue: transformationKey,\n              description: expectedValidationMessage,\n            }),\n          );\n        },\n      );\n    });\n\n    describe('invalid transformations values', () => {\n      describe('custom function expressions', () => {\n        const invalidCustomFunctionName = '#1a';\n\n        describe('invalid custom function-name is used', () => {\n          test.each`\n            description    | transformation                                    | expectedParentPath\n            ${'top level'} | ${invalidCustomFunctionName}                      | ${null}\n            ${'nested'}    | ${{ a: { b: { c: invalidCustomFunctionName } } }} | ${'a.b.c'}\n          `(\n            'returns a validation error for $description cases',\n            ({ expectedParentPath, transformation }) => {\n              expect(\n                validateResponseTransformation(transformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: invalidCustomFunctionName,\n                  description: 'contains an invalid custom function expression',\n                }),\n              );\n            },\n          );\n        });\n\n        describe('a custom function argument is invalid in response transformation', () => {\n          const invalidCustomFunctionExpression = '#someFunction($[0])';\n\n          test.each`\n            description    | transformation                                          | expectedParentPath\n            ${'top level'} | ${invalidCustomFunctionExpression}                      | ${null}\n            ${'nested'}    | ${{ a: { b: { c: invalidCustomFunctionExpression } } }} | ${'a.b.c'}\n          `(\n            'returns a validation error for $description cases',\n            ({ expectedParentPath, transformation }) => {\n              expect(\n                validateResponseTransformation(transformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: '$[0]',\n                  description: \"must be a string starting with '$.'\",\n                }),\n              );\n            },\n          );\n        });\n\n        test('returns a validation error when an argument index is used', () => {\n          const argumentExpression = '$[1].a.b.c.';\n          const path = 'd.e.f';\n          const transformation = set({}, path, argumentExpression);\n\n          expect(validateResponseTransformation(transformation)).toStrictEqual(\n            validationErrorWith({\n              parentPath: path,\n              invalidValue: argumentExpression,\n              description: \"must be a string starting with '$.'\",\n            }),\n          );\n        });\n      });\n\n      describe.each`\n        description                  | transformationValue | expectedValidationMessage\n        ${'does not start with $'}   | ${'a.b.c'}          | ${\"must be a string starting with '$.'\"}\n        ${'refers to * in the path'} | ${'$.a.b.*'}        | ${'cannot refer to the * operator'}\n      `(\n        'returns a validation error when a transformation value segment $description',\n        ({ transformationValue, expectedValidationMessage }) => {\n          test('simple transformation', () => {\n            expect(\n              validateResponseTransformation(transformationValue),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: null,\n                invalidValue: transformationValue,\n                description: expectedValidationMessage,\n              }),\n            );\n          });\n\n          test('complex transformation', () => {\n            const transformation = { d: { e: { f: transformationValue } } };\n\n            expect(\n              validateResponseTransformation(transformation),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: 'd.e.f',\n                invalidValue: transformationValue,\n                description: expectedValidationMessage,\n              }),\n            );\n          });\n        },\n      );\n\n      describe('special fields', () => {\n        describe.each(['_id', '_createdDate', '_updatedDate'])(\n          '%s',\n          (specialField) => {\n            const expectedValidationMessage = `cannot refer to the ${specialField} field`;\n\n            test('returns a validation error when a transformation value segment $description', () => {\n              const transformation = {\n                d: { e: { f: { [specialField]: '$.a.b.c' } } },\n                '*': '$[1]',\n              };\n\n              expect(\n                validateResponseTransformation(transformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: 'd.e.f',\n                  invalidValue: specialField,\n                  description: expectedValidationMessage,\n                }),\n              );\n            });\n\n            describe('simple transformation', () => {\n              test(`returns a validation error when a segment refers to the special field ${specialField}`, () => {\n                const transformationValue = `$.a.b.${specialField}`;\n\n                expect(\n                  validateResponseTransformation(transformationValue),\n                ).toStrictEqual(\n                  validationErrorWith({\n                    parentPath: null,\n                    invalidValue: transformationValue,\n                    description: expectedValidationMessage,\n                  }),\n                );\n              });\n            });\n\n            test('complex transformation', () => {\n              const transformationValue = `$.a.b.${specialField}`;\n              const transformation = { d: { e: { f: transformationValue } } };\n\n              expect(\n                validateResponseTransformation(transformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: 'd.e.f',\n                  invalidValue: transformationValue,\n                  description: expectedValidationMessage,\n                }),\n              );\n            });\n          },\n        );\n      });\n    });\n\n    describe('omit transformation', () => {\n      describe('invalid @source', () => {\n        const invalidSourceValue = 'a.b.c';\n        const invalidSourceTransformation = {\n          '@source': invalidSourceValue,\n          '@omit': times(2, () => aString()),\n        };\n\n        test.each`\n          description    | invalidTransformation                           | expectedParentPath\n          ${'top level'} | ${invalidSourceTransformation}                  | ${'@source'}\n          ${'nested'}    | ${{ [parentKey]: invalidSourceTransformation }} | ${`${parentKey}.@source`}\n        `(\n          'returns a validation error when the @source value is invalid',\n          ({ invalidTransformation, expectedParentPath }) => {\n            expect(\n              validateResponseTransformation(invalidTransformation),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: expectedParentPath,\n                invalidValue: invalidSourceValue,\n                description: \"must be a string starting with '$.'\",\n              }),\n            );\n          },\n        );\n      });\n\n      describe('invalid @omit', () => {\n        const transformationWithOmitValue = (value) => ({\n          '@source': '$.a.b.c',\n          '@omit': value,\n        });\n\n        const nonArray = aString();\n        const nonStringArray = times(2, () => aNumber());\n        const arrayWithInvalidPaths = ['a.b.c', aString()];\n\n        describe.each`\n          description    | invalidTransformation                                     | expectedParentPath\n          ${'top level'} | ${transformationWithOmitValue(nonArray)}                  | ${'@omit'}\n          ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(nonArray) }} | ${`${parentKey}.@omit`}\n        `(\n          '@omit is not an array',\n          ({ description, invalidTransformation, expectedParentPath }) => {\n            test(`returns a validation error for invalid ${description} transformation`, () => {\n              expect(\n                validateResponseTransformation(invalidTransformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: nonArray,\n                  description: 'must be an array of strings',\n                }),\n              );\n            });\n          },\n        );\n\n        describe.each`\n          description    | invalidTransformation                                           | expectedParentPath\n          ${'top level'} | ${transformationWithOmitValue(nonStringArray)}                  | ${'@omit'}\n          ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(nonStringArray) }} | ${`${parentKey}.@omit`}\n        `(\n          '@omit is an array of non-strings',\n          ({ description, invalidTransformation, expectedParentPath }) => {\n            test(`returns a validation error for invalid ${description} transformation`, () => {\n              expect(\n                validateResponseTransformation(invalidTransformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: nonStringArray,\n                  description: 'must be an array of strings',\n                }),\n              );\n            });\n          },\n        );\n\n        /* eslint-disable max-len */\n        describe.each`\n          description    | invalidTransformation                                                  | expectedParentPath\n          ${'top level'} | ${transformationWithOmitValue(arrayWithInvalidPaths)}                  | ${'@omit'}\n          ${'nested'}    | ${{ [parentKey]: transformationWithOmitValue(arrayWithInvalidPaths) }} | ${`${parentKey}.@omit`}\n        `(\n          '@omit is an array of invalid string paths',\n          ({ description, invalidTransformation, expectedParentPath }) => {\n            /* eslint-enable max-len */\n            test(`returns a validation error for invalid ${description} transformation`, () => {\n              expect(\n                validateResponseTransformation(invalidTransformation),\n              ).toStrictEqual(\n                validationErrorWith({\n                  parentPath: expectedParentPath,\n                  invalidValue: arrayWithInvalidPaths,\n                  description: 'must contain non-nested paths only',\n                }),\n              );\n            });\n          },\n        );\n      });\n    });\n\n    describe('array-item transformation', () => {\n      const validValue = '$.d.e.f';\n\n      const invalidPathTransformationWith = (invalidPathValue) => ({\n        '@path': invalidPathValue,\n        '@itemTransformation': validValue,\n      });\n\n      describe.each`\n        invalidValue                                            | description\n        ${'$[0].should.fail'}                                   | ${'invalid path value'}\n        ${aRandomItemFrom([aBoolean(), aNumber(), anObject()])} | ${'invalid path type'}\n      `('$description', ({ invalidValue }) => {\n        test.each`\n          description    | invalidTransformation                                           | expectedParentPath\n          ${'top-level'} | ${invalidPathTransformationWith(invalidValue)}                  | ${'@path'}\n          ${'nested'}    | ${{ [parentKey]: invalidPathTransformationWith(invalidValue) }} | ${`${parentKey}.@path`}\n        `(\n          'returns a validation error when the @path value is invalid for $description transformation',\n          ({ invalidTransformation, expectedParentPath }) => {\n            expect(\n              validateResponseTransformation(invalidTransformation),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: expectedParentPath,\n                invalidValue,\n                description: \"must be a string starting with '$.'\",\n              }),\n            );\n          },\n        );\n      });\n\n      describe('invalid @itemTransformation', () => {\n        const invalidValue = '$[0].should.fail';\n        const invalidPathTransformation = {\n          '@path': validValue,\n          '@itemTransformation': invalidValue,\n        };\n\n        test.each`\n          description    | invalidTransformation                         | expectedParentPath\n          ${'top-level'} | ${invalidPathTransformation}                  | ${'@itemTransformation'}\n          ${'nested'}    | ${{ [parentKey]: invalidPathTransformation }} | ${`${parentKey}.@itemTransformation`}\n        `(\n          'returns a validation error when the @itemTransformation value is invalid for $description transformation',\n          ({ invalidTransformation, expectedParentPath }) => {\n            expect(\n              validateResponseTransformation(invalidTransformation),\n            ).toStrictEqual(\n              validationErrorWith({\n                parentPath: expectedParentPath,\n                invalidValue,\n                description: \"must be a string starting with '$.'\",\n              }),\n            );\n          },\n        );\n      });\n    });\n  });\n});\n"]}

package/dist/cjs/index.js

@@ -0,0 +1,102 @@
+"use strict";
+
+exports.__esModule = true;
+exports.validation = exports.transformations = exports.preset = exports.namingHints = exports.corvidEntities = void 0;
+
+var _corvidEntity = require("./lib/corvid-entity");
+
+var _getArgumentCardinality = require("./lib/getArgumentCardinality");
+
+exports.getArgumentCardinality = _getArgumentCardinality.getArgumentCardinality;
+
+var _helpers = require("./lib/helpers");
+
+exports.isSimpleTransformation = _helpers.isSimpleTransformation;
+exports.isArrayIndexString = _helpers.isArrayIndexString;
+exports.isSpreadOperator = _helpers.isSpreadOperator;
+exports.extractIndexAndPath = _helpers.extractIndexAndPath;
+exports.isIdentityResponseTransformation = _helpers.isIdentityResponseTransformation;
+exports.isRootObjectIdentifier = _helpers.isRootObjectIdentifier;
+exports.stripJsonPathRootPrefix = _helpers.stripJsonPathRootPrefix;
+exports.getArgumentIndex = _helpers.getArgumentIndex;
+exports.isMapArrayItemsTransformation = _helpers.isMapArrayItemsTransformation;
+exports.isOmitTransformation = _helpers.isOmitTransformation;
+exports.parseOmitTransformation = _helpers.parseOmitTransformation;
+exports.isJsonPathExpression = _helpers.isJsonPathExpression;
+
+var _common = require("./lib/transformations/common");
+
+var _customFunctions = require("./lib/transformations/custom-functions");
+
+exports.runCustomFunctionCallExpression = _customFunctions.runCustomFunctionCallExpression;
+exports.parseCustomFunctionCall = _customFunctions.parseCustomFunctionCall;
+exports.isFunctionCallExpression = _customFunctions.isFunctionCallExpression;
+
+var _create = require("./lib/transformations/preset/create");
+
+var _delete = require("./lib/transformations/preset/delete");
+
+var _get = require("./lib/transformations/preset/get");
+
+var _list = require("./lib/transformations/preset/list");
+
+var _query = require("./lib/transformations/preset/query");
+
+var _update = require("./lib/transformations/preset/update");
+
+var _reduceTransformation = require("./lib/transformations/reduceTransformation");
+
+exports.reduceTransformation = _reduceTransformation.reduceTransformation;
+
+var _validateRequestTransformation = require("./lib/transformations/validations/validateRequestTransformation");
+
+var _validateResponseTransformation = require("./lib/transformations/validations/validateResponseTransformation");
+
+const JS_SINGLE_ARG_UNCHANGED = _common.transformations.JS_SINGLE_ARG_UNCHANGED,
+      RESPONSE_OBJECT_UNCHANGED = _common.transformations.RESPONSE_OBJECT_UNCHANGED,
+      ARRAY_ITEMS_PATH_PROPERTY_NAME = _common.transformations.ARRAY_ITEMS_PATH_PROPERTY_NAME,
+      ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME = _common.transformations.ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME,
+      OMIT_SOURCE_PROPERTY_NAME = _common.transformations.OMIT_SOURCE_PROPERTY_NAME,
+      FIELDS_TO_OMIT_PROPERTY_NAME = _common.transformations.FIELDS_TO_OMIT_PROPERTY_NAME;
+const transformations = {
+  JS_SINGLE_ARG_UNCHANGED,
+  RESPONSE_OBJECT_UNCHANGED,
+  ARRAY_ITEMS_PATH_PROPERTY_NAME,
+  ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME,
+  OMIT_SOURCE_PROPERTY_NAME,
+  FIELDS_TO_OMIT_PROPERTY_NAME
+};
+exports.transformations = transformations;
+
+const transformationBuilder = (buildRequestTransformation, buildResponseTransformation) => ({
+  buildRequestTransformation,
+  buildResponseTransformation
+});
+
+const preset = {
+  create: transformationBuilder(_create.buildRequestTransformation, _create.buildResponseTransformation),
+  update: transformationBuilder(_update.buildRequestTransformation, _update.buildResponseTransformation),
+  delete: transformationBuilder(_delete.buildRequestTransformation, _delete.buildResponseTransformation),
+  get: transformationBuilder(_get.buildRequestTransformation, _get.buildResponseTransformation),
+  list: transformationBuilder(_list.buildRequestTransformation, _list.buildResponseTransformation),
+  query: { ...transformationBuilder(_query.buildRequestTransformation, _query.buildResponseTransformation),
+    ITEMS_RESULT_PROPERTY_NAME: _query.ITEMS_RESULT_PROPERTY_NAME,
+    PAGING_METADATA_RESULT_PROPERTY_NAME: _query.PAGING_METADATA_RESULT_PROPERTY_NAME
+  }
+};
+exports.preset = preset;
+const namingHints = {
+  OPTIONS: 'OPTIONS'
+};
+exports.namingHints = namingHints;
+const validation = {
+  validateRequestTransformation: _validateRequestTransformation.validateRequestTransformation,
+  validateResponseTransformation: _validateResponseTransformation.validateResponseTransformation
+};
+exports.validation = validation;
+const corvidEntities = {
+  toCorvidName: _corvidEntity.toCorvidName,
+  fromCorvidName: _corvidEntity.fromCorvidName
+};
+exports.corvidEntities = corvidEntities;
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"names":["JS_SINGLE_ARG_UNCHANGED","allTransformations","RESPONSE_OBJECT_UNCHANGED","ARRAY_ITEMS_PATH_PROPERTY_NAME","ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME","OMIT_SOURCE_PROPERTY_NAME","FIELDS_TO_OMIT_PROPERTY_NAME","transformations","transformationBuilder","buildRequestTransformation","buildResponseTransformation","preset","create","buildCreateRequestTransformation","buildCreateResponseTransformation","update","buildUpdateRequestTransformation","buildUpdateResponseTransformation","delete","buildDeleteRequestTransformation","buildDeleteResponseTransformation","get","buildGetRequestTransformation","buildGetResponseTransformation","list","buildListRequestTransformation","buildListResponseTransformation","query","buildQueryRequestTransformation","buildQueryResponseTransformation","ITEMS_RESULT_PROPERTY_NAME","PAGING_METADATA_RESULT_PROPERTY_NAME","namingHints","OPTIONS","validation","validateRequestTransformation","validateResponseTransformation","corvidEntities","toCorvidName","fromCorvidName"],"mappings":";;;;;AAAA;;AACA;;;;AACA;;;;;;;;;;;;;;;AAcA;;AAoBA;;;;;;AAMA;;AAIA;;AAIA;;AAIA;;AAIA;;AAMA;;AAIA;;;;AACA;;AACA;;AApDA,MACEA,uBADF,GAOIC,uBAPJ,CACED,uBADF;AAAA,MAEEE,yBAFF,GAOID,uBAPJ,CAEEC,yBAFF;AAAA,MAGEC,8BAHF,GAOIF,uBAPJ,CAGEE,8BAHF;AAAA,MAIEC,uCAJF,GAOIH,uBAPJ,CAIEG,uCAJF;AAAA,MAKEC,yBALF,GAOIJ,uBAPJ,CAKEI,yBALF;AAAA,MAMEC,4BANF,GAOIL,uBAPJ,CAMEK,4BANF;AASA,MAAMC,eAAe,GAAG;AACtBP,EAAAA,uBADsB;AAEtBE,EAAAA,yBAFsB;AAGtBC,EAAAA,8BAHsB;AAItBC,EAAAA,uCAJsB;AAKtBC,EAAAA,yBALsB;AAMtBC,EAAAA;AANsB,CAAxB;;;AA6CA,MAAME,qBAAqB,GAAG,CAC5BC,0BAD4B,EAE5BC,2BAF4B,MAGxB;AACJD,EAAAA,0BADI;AAEJC,EAAAA;AAFI,CAHwB,CAA9B;;AAQA,MAAMC,MAAM,GAAG;AACbC,EAAAA,MAAM,EAAEJ,qBAAqB,CAC3BK,kCAD2B,EAE3BC,mCAF2B,CADhB;AAKbC,EAAAA,MAAM,EAAEP,qBAAqB,CAC3BQ,kCAD2B,EAE3BC,mCAF2B,CALhB;AASbC,EAAAA,MAAM,EAAEV,qBAAqB,CAC3BW,kCAD2B,EAE3BC,mCAF2B,CAThB;AAabC,EAAAA,GAAG,EAAEb,qBAAqB,CACxBc,+BADwB,EAExBC,gCAFwB,CAbb;AAiBbC,EAAAA,IAAI,EAAEhB,qBAAqB,CACzBiB,gCADyB,EAEzBC,iCAFyB,CAjBd;AAqBbC,EAAAA,KAAK,EAAE,EACL,GAAGnB,qBAAqB,CACtBoB,iCADsB,EAEtBC,kCAFsB,CADnB;AAKLC,IAAAA,0BAA0B,EAA1BA,iCALK;AAMLC,IAAAA,oCAAoC,EAApCA;AANK;AArBM,CAAf;;AA+BA,MAAMC,WAAW,GAAG;AAAEC,EAAAA,OAAO,EAAE;AAAX,CAApB;;AAEA,MAAMC,UAAU,GAAG;AACjBC,EAAAA,6BAA6B,EAA7BA,4DADiB;AAEjBC,EAAAA,8BAA8B,EAA9BA;AAFiB,CAAnB;;AAKA,MAAMC,cAAc,GAAG;AACrBC,EAAAA,YAAY,EAAZA,0BADqB;AAErBC,EAAAA,cAAc,EAAdA;AAFqB,CAAvB","sourcesContent":["import { toCorvidName, fromCorvidName } from './lib/corvid-entity';\nimport { getArgumentCardinality } from './lib/getArgumentCardinality';\nimport {\n  isSimpleTransformation,\n  isArrayIndexString,\n  isSpreadOperator,\n  extractIndexAndPath,\n  isIdentityResponseTransformation,\n  isRootObjectIdentifier,\n  stripJsonPathRootPrefix,\n  getArgumentIndex,\n  isMapArrayItemsTransformation,\n  isOmitTransformation,\n  parseOmitTransformation,\n  isJsonPathExpression,\n} from './lib/helpers';\nimport { transformations as allTransformations } from './lib/transformations/common';\n\nconst {\n  JS_SINGLE_ARG_UNCHANGED,\n  RESPONSE_OBJECT_UNCHANGED,\n  ARRAY_ITEMS_PATH_PROPERTY_NAME,\n  ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME,\n  OMIT_SOURCE_PROPERTY_NAME,\n  FIELDS_TO_OMIT_PROPERTY_NAME,\n} = allTransformations;\n\nconst transformations = {\n  JS_SINGLE_ARG_UNCHANGED,\n  RESPONSE_OBJECT_UNCHANGED,\n  ARRAY_ITEMS_PATH_PROPERTY_NAME,\n  ARRAY_ITEM_TRANSFORMATION_PROPERTY_NAME,\n  OMIT_SOURCE_PROPERTY_NAME,\n  FIELDS_TO_OMIT_PROPERTY_NAME,\n};\n\nimport {\n  runCustomFunctionCallExpression,\n  parseCustomFunctionCall,\n  isFunctionCallExpression,\n} from './lib/transformations/custom-functions';\n\nimport {\n  buildRequestTransformation as buildCreateRequestTransformation,\n  buildResponseTransformation as buildCreateResponseTransformation,\n} from './lib/transformations/preset/create';\nimport {\n  buildRequestTransformation as buildDeleteRequestTransformation,\n  buildResponseTransformation as buildDeleteResponseTransformation,\n} from './lib/transformations/preset/delete';\nimport {\n  buildRequestTransformation as buildGetRequestTransformation,\n  buildResponseTransformation as buildGetResponseTransformation,\n} from './lib/transformations/preset/get';\nimport {\n  buildRequestTransformation as buildListRequestTransformation,\n  buildResponseTransformation as buildListResponseTransformation,\n} from './lib/transformations/preset/list';\nimport {\n  buildRequestTransformation as buildQueryRequestTransformation,\n  buildResponseTransformation as buildQueryResponseTransformation,\n  ITEMS_RESULT_PROPERTY_NAME,\n  PAGING_METADATA_RESULT_PROPERTY_NAME,\n} from './lib/transformations/preset/query';\nimport {\n  buildRequestTransformation as buildUpdateRequestTransformation,\n  buildResponseTransformation as buildUpdateResponseTransformation,\n} from './lib/transformations/preset/update';\nimport { reduceTransformation } from './lib/transformations/reduceTransformation';\nimport { validateRequestTransformation } from './lib/transformations/validations/validateRequestTransformation';\nimport { validateResponseTransformation } from './lib/transformations/validations/validateResponseTransformation';\n\nconst transformationBuilder = (\n  buildRequestTransformation,\n  buildResponseTransformation,\n) => ({\n  buildRequestTransformation,\n  buildResponseTransformation,\n});\n\nconst preset = {\n  create: transformationBuilder(\n    buildCreateRequestTransformation,\n    buildCreateResponseTransformation,\n  ),\n  update: transformationBuilder(\n    buildUpdateRequestTransformation,\n    buildUpdateResponseTransformation,\n  ),\n  delete: transformationBuilder(\n    buildDeleteRequestTransformation,\n    buildDeleteResponseTransformation,\n  ),\n  get: transformationBuilder(\n    buildGetRequestTransformation,\n    buildGetResponseTransformation,\n  ),\n  list: transformationBuilder(\n    buildListRequestTransformation,\n    buildListResponseTransformation,\n  ),\n  query: {\n    ...transformationBuilder(\n      buildQueryRequestTransformation,\n      buildQueryResponseTransformation,\n    ),\n    ITEMS_RESULT_PROPERTY_NAME,\n    PAGING_METADATA_RESULT_PROPERTY_NAME,\n  },\n};\n\nconst namingHints = { OPTIONS: 'OPTIONS' };\n\nconst validation = {\n  validateRequestTransformation,\n  validateResponseTransformation,\n};\n\nconst corvidEntities = {\n  toCorvidName,\n  fromCorvidName,\n};\n\nexport {\n  transformations,\n  preset,\n  namingHints,\n  getArgumentCardinality,\n  isSimpleTransformation,\n  isArrayIndexString,\n  isSpreadOperator,\n  isMapArrayItemsTransformation,\n  isOmitTransformation,\n  parseOmitTransformation,\n  isFunctionCallExpression,\n  parseCustomFunctionCall,\n  extractIndexAndPath,\n  isIdentityResponseTransformation,\n  isRootObjectIdentifier,\n  stripJsonPathRootPrefix,\n  getArgumentIndex,\n  isJsonPathExpression,\n  validation,\n  corvidEntities,\n  runCustomFunctionCallExpression,\n  reduceTransformation,\n};\n"]}

package/dist/cjs/lib/corvid-entity/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports.toCorvidName = exports.isReservedCorvidFieldName = exports.isReservedCommonFieldName = exports.fromCorvidName = exports.TO_CORVID_ENTITY_RENAMED_KEYS = exports.FROM_CORVID_ENTITY_RENAMED_KEYS = void 0;
+
+var _lodash = require("lodash");
+
+const TO_CORVID_ENTITY_RENAMED_KEYS = {
+  id: '_id',
+  createdDate: '_createdDate',
+  updatedDate: '_updatedDate'
+};
+exports.TO_CORVID_ENTITY_RENAMED_KEYS = TO_CORVID_ENTITY_RENAMED_KEYS;
+const FROM_CORVID_ENTITY_RENAMED_KEYS = (0, _lodash.invert)(TO_CORVID_ENTITY_RENAMED_KEYS);
+exports.FROM_CORVID_ENTITY_RENAMED_KEYS = FROM_CORVID_ENTITY_RENAMED_KEYS;
+
+const isReservedCorvidFieldName = name => name in FROM_CORVID_ENTITY_RENAMED_KEYS;
+
+exports.isReservedCorvidFieldName = isReservedCorvidFieldName;
+
+const isReservedCommonFieldName = name => name in TO_CORVID_ENTITY_RENAMED_KEYS;
+
+exports.isReservedCommonFieldName = isReservedCommonFieldName;
+
+const toCorvidName = name => TO_CORVID_ENTITY_RENAMED_KEYS[name] || name;
+
+exports.toCorvidName = toCorvidName;
+
+const fromCorvidName = name => FROM_CORVID_ENTITY_RENAMED_KEYS[name] || name;
+
+exports.fromCorvidName = fromCorvidName;
+//# sourceMappingURL=index.js.map

package/dist/cjs/lib/corvid-entity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/corvid-entity/index.ts"],"names":["TO_CORVID_ENTITY_RENAMED_KEYS","id","createdDate","updatedDate","FROM_CORVID_ENTITY_RENAMED_KEYS","isReservedCorvidFieldName","name","isReservedCommonFieldName","toCorvidName","fromCorvidName"],"mappings":";;;;;AAAA;;AAEA,MAAMA,6BAA6B,GAAG;AACpCC,EAAAA,EAAE,EAAE,KADgC;AAEpCC,EAAAA,WAAW,EAAE,cAFuB;AAGpCC,EAAAA,WAAW,EAAE;AAHuB,CAAtC;;AAKA,MAAMC,+BAA+B,GAAG,oBAAOJ,6BAAP,CAAxC;;;AAEA,MAAMK,yBAAyB,GAAIC,IAAD,IAChCA,IAAI,IAAIF,+BADV;;;;AAGA,MAAMG,yBAAyB,GAAID,IAAD,IAChCA,IAAI,IAAIN,6BADV;;;;AAGA,MAAMQ,YAAY,GAAIF,IAAD,IAAUN,6BAA6B,CAACM,IAAD,CAA7B,IAAuCA,IAAtE;;;;AAEA,MAAMG,cAAc,GAAIH,IAAD,IAAUF,+BAA+B,CAACE,IAAD,CAA/B,IAAyCA,IAA1E","sourcesContent":["import { invert } from 'lodash';\n\nconst TO_CORVID_ENTITY_RENAMED_KEYS = {\n  id: '_id',\n  createdDate: '_createdDate',\n  updatedDate: '_updatedDate',\n};\nconst FROM_CORVID_ENTITY_RENAMED_KEYS = invert(TO_CORVID_ENTITY_RENAMED_KEYS);\n\nconst isReservedCorvidFieldName = (name) =>\n  name in FROM_CORVID_ENTITY_RENAMED_KEYS;\n\nconst isReservedCommonFieldName = (name) =>\n  name in TO_CORVID_ENTITY_RENAMED_KEYS;\n\nconst toCorvidName = (name) => TO_CORVID_ENTITY_RENAMED_KEYS[name] || name;\n\nconst fromCorvidName = (name) => FROM_CORVID_ENTITY_RENAMED_KEYS[name] || name;\n\nexport {\n  TO_CORVID_ENTITY_RENAMED_KEYS,\n  FROM_CORVID_ENTITY_RENAMED_KEYS,\n  toCorvidName,\n  fromCorvidName,\n  isReservedCorvidFieldName,\n  isReservedCommonFieldName,\n};\n"]}

package/dist/cjs/lib/getArgumentCardinality.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.getArgumentCardinality = void 0;
+
+var _lodash = require("lodash");
+
+const extractArgumentFromString = (str, seen = new Set()) => {
+  // We expect a single argument in a valid string-transformation at most, e.g. $[1].someField
+  const matches = str.match(/(\$\[\d+\])/);
+
+  if (matches) {
+    seen.add(matches.pop());
+  }
+
+  return seen;
+};
+
+const extractArgumensFromObject = (object, seen = new Set()) => Object.keys(object).reduce((acc, key) => {
+  const value = object[key];
+
+  if ((0, _lodash.isPlainObject)(value) || (0, _lodash.isArray)(value)) {
+    extractArgumensFromObject(value, seen);
+  } else if (typeof value === 'string') {
+    extractArgumentFromString(value, seen);
+  }
+
+  return acc;
+}, seen);
+
+const getArgumentCardinality = transformation => typeof transformation === 'string' ? extractArgumentFromString(transformation).size : extractArgumensFromObject(transformation).size;
+
+exports.getArgumentCardinality = getArgumentCardinality;
+//# sourceMappingURL=getArgumentCardinality.js.map

package/dist/cjs/lib/getArgumentCardinality.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/getArgumentCardinality.ts"],"names":["extractArgumentFromString","str","seen","Set","matches","match","add","pop","extractArgumensFromObject","object","Object","keys","reduce","acc","key","value","getArgumentCardinality","transformation","size"],"mappings":";;;;;AAAA;;AAEA,MAAMA,yBAAyB,GAAG,CAACC,GAAD,EAAMC,IAAI,GAAG,IAAIC,GAAJ,EAAb,KAA2B;AAC3D;AACA,QAAMC,OAAO,GAAGH,GAAG,CAACI,KAAJ,CAAU,aAAV,CAAhB;;AAEA,MAAID,OAAJ,EAAa;AACXF,IAAAA,IAAI,CAACI,GAAL,CAASF,OAAO,CAACG,GAAR,EAAT;AACD;;AAED,SAAOL,IAAP;AACD,CATD;;AAWA,MAAMM,yBAAyB,GAAG,CAACC,MAAD,EAASP,IAAI,GAAG,IAAIC,GAAJ,EAAhB,KAChCO,MAAM,CAACC,IAAP,CAAYF,MAAZ,EAAoBG,MAApB,CAA2B,CAACC,GAAD,EAAMC,GAAN,KAAc;AACvC,QAAMC,KAAK,GAAGN,MAAM,CAACK,GAAD,CAApB;;AAEA,MAAI,2BAAcC,KAAd,KAAwB,qBAAQA,KAAR,CAA5B,EAA4C;AAC1CP,IAAAA,yBAAyB,CAACO,KAAD,EAAQb,IAAR,CAAzB;AACD,GAFD,MAEO,IAAI,OAAOa,KAAP,KAAiB,QAArB,EAA+B;AACpCf,IAAAA,yBAAyB,CAACe,KAAD,EAAQb,IAAR,CAAzB;AACD;;AAED,SAAOW,GAAP;AACD,CAVD,EAUGX,IAVH,CADF;;AAaA,MAAMc,sBAAsB,GAAIC,cAAD,IAC7B,OAAOA,cAAP,KAA0B,QAA1B,GACIjB,yBAAyB,CAACiB,cAAD,CAAzB,CAA0CC,IAD9C,GAEIV,yBAAyB,CAACS,cAAD,CAAzB,CAA0CC,IAHhD","sourcesContent":["import { isPlainObject, isArray } from 'lodash';\n\nconst extractArgumentFromString = (str, seen = new Set()) => {\n  // We expect a single argument in a valid string-transformation at most, e.g. $[1].someField\n  const matches = str.match(/(\\$\\[\\d+\\])/);\n\n  if (matches) {\n    seen.add(matches.pop());\n  }\n\n  return seen;\n};\n\nconst extractArgumensFromObject = (object, seen = new Set()) =>\n  Object.keys(object).reduce((acc, key) => {\n    const value = object[key];\n\n    if (isPlainObject(value) || isArray(value)) {\n      extractArgumensFromObject(value, seen);\n    } else if (typeof value === 'string') {\n      extractArgumentFromString(value, seen);\n    }\n\n    return acc;\n  }, seen);\n\nconst getArgumentCardinality = (transformation) =>\n  typeof transformation === 'string'\n    ? extractArgumentFromString(transformation).size\n    : extractArgumensFromObject(transformation).size;\n\nexport { getArgumentCardinality };\n"]}