@aws-amplify/graphql-api-construct 1.1.0

package/lib/internal/user-defined-slots.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUserDefinedSlots = exports.getSlotName = exports.separateSlots = exports.validateFunctionSlots = void 0;
+/**
+ * Validate that only supported props are being passed into the funciton slots.
+ * @param functionSlots the slot inputs to validate.
+ */
+const validateFunctionSlots = (functionSlots) => {
+    functionSlots.forEach(({ function: { responseMappingTemplate, requestMappingTemplate } }) => {
+        if (!requestMappingTemplate && !responseMappingTemplate) {
+            throw new Error('Expected at least one of either requestMappingTemplate or responseMappingTemplate');
+        }
+    });
+};
+exports.validateFunctionSlots = validateFunctionSlots;
+/**
+ * We'll partition any slots have both a request and response mapping template into two to make the existing system work.
+ * @param functionSlots the possibly consolidated slots.
+ * @returns no longer consolidated slots.
+ */
+const separateSlots = (functionSlots) => functionSlots.flatMap((slot) => {
+    if (slot.function.requestMappingTemplate && slot.function.responseMappingTemplate) {
+        return [
+            {
+                ...slot,
+                function: {
+                    requestMappingTemplate: slot.function.requestMappingTemplate,
+                },
+            },
+            {
+                ...slot,
+                function: {
+                    responseMappingTemplate: slot.function.responseMappingTemplate,
+                },
+            },
+        ];
+    }
+    return [slot];
+});
+exports.separateSlots = separateSlots;
+/**
+ * Given a set of strongly typed input params, generate a valid transformer slot name.
+ * @param params the slot configuration
+ * @returns the slot id
+ */
+const getSlotName = (params) => [
+    params.typeName,
+    params.fieldName,
+    params.slotName,
+    params.slotIndex,
+    params.function.requestMappingTemplate ? 'req' : 'res',
+    'vtl',
+].join('.');
+exports.getSlotName = getSlotName;
+/**
+ * Utility to avoid using lodash.
+ * @param obj the object to deeply set values in.
+ * @param path the access path.
+ * @param val the value to set.
+ */
+const setIn = (obj, path, val) => {
+    if (path.length === 1) {
+        // eslint-disable-next-line no-param-reassign
+        obj[path[0]] = val;
+        return;
+    }
+    if (!obj[path[0]]) {
+        // eslint-disable-next-line no-param-reassign
+        obj[path[0]] = {};
+    }
+    setIn(obj[path[0]], path.slice(1), val);
+};
+const parseUserDefinedSlots = (userDefinedTemplates) => {
+    const groupedResolversMap = {};
+    userDefinedTemplates
+        .map((slot) => [
+        (0, exports.getSlotName)(slot),
+        slot.function.requestMappingTemplate
+            ? slot.function.requestMappingTemplate.renderTemplate()
+            : slot.function.responseMappingTemplate?.renderTemplate() ?? '',
+    ])
+        .forEach(([fileName, template]) => {
+        const slicedSlotName = fileName.split('.');
+        const resolverType = slicedSlotName[slicedSlotName.length - 2] === 'res' ? 'responseResolver' : 'requestResolver';
+        const resolverName = [slicedSlotName[0], slicedSlotName[1]].join('.');
+        const slotName = slicedSlotName[2];
+        const resolverOrder = `order${Number(slicedSlotName[3]) || 0}`;
+        const resolver = {
+            fileName,
+            template,
+        };
+        const slotHash = `${resolverName}#${slotName}`;
+        // because a slot can have a request and response resolver, we need to group corresponding request and response resolvers
+        if (slotHash in groupedResolversMap && resolverOrder in groupedResolversMap[slotHash]) {
+            setIn(groupedResolversMap, [slotHash, resolverOrder, resolverType], resolver);
+        }
+        else {
+            const slot = {
+                resolverTypeName: slicedSlotName[0],
+                resolverFieldName: slicedSlotName[1],
+                slotName,
+                [resolverType]: resolver,
+            };
+            setIn(groupedResolversMap, [slotHash, resolverOrder], slot);
+        }
+    });
+    return Object.entries(groupedResolversMap)
+        .map(([resolverNameKey, numberedSlots]) => ({
+        orderedSlots: Object.entries(numberedSlots)
+            .sort(([i], [j]) => i.localeCompare(j))
+            .map(([_, slot]) => slot),
+        resolverName: resolverNameKey.split('#')[0],
+    }))
+        .reduce((acc, { orderedSlots, resolverName }) => {
+        if (acc[resolverName]) {
+            acc[resolverName].push(...orderedSlots);
+        }
+        else {
+            acc[resolverName] = orderedSlots;
+        }
+        return acc;
+    }, {});
+};
+exports.parseUserDefinedSlots = parseUserDefinedSlots;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-defined-slots.js","sourceRoot":"","sources":["../../src/internal/user-defined-slots.ts"],"names":[],"mappings":";;;AAGA;;;GAGG;AACI,MAAM,qBAAqB,GAAG,CAAC,aAA6B,EAAQ,EAAE;IAC3E,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,EAAE,EAAE,EAAE;QAC1F,IAAI,CAAC,sBAAsB,IAAI,CAAC,uBAAuB,EAAE;YACvD,MAAM,IAAI,KAAK,CAAC,mFAAmF,CAAC,CAAC;SACtG;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AANW,QAAA,qBAAqB,yBAMhC;AAEF;;;;GAIG;AACI,MAAM,aAAa,GAAG,CAAC,aAA6B,EAAkB,EAAE,CAC7E,aAAa,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;IAC7B,IAAI,IAAI,CAAC,QAAQ,CAAC,sBAAsB,IAAI,IAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE;QACjF,OAAO;YACL;gBACE,GAAG,IAAI;gBACP,QAAQ,EAAE;oBACR,sBAAsB,EAAE,IAAI,CAAC,QAAQ,CAAC,sBAAsB;iBAC7D;aACF;YACD;gBACE,GAAG,IAAI;gBACP,QAAQ,EAAE;oBACR,uBAAuB,EAAE,IAAI,CAAC,QAAQ,CAAC,uBAAuB;iBAC/D;aACF;SACF,CAAC;KACH;IACD,OAAO,CAAC,IAAI,CAAC,CAAC;AAChB,CAAC,CAAC,CAAC;AAnBQ,QAAA,aAAa,iBAmBrB;AAEL;;;;GAIG;AACI,MAAM,WAAW,GAAG,CAAC,MAAoB,EAAU,EAAE,CAC1D;IACE,MAAM,CAAC,QAAQ;IACf,MAAM,CAAC,SAAS;IAChB,MAAM,CAAC,QAAQ;IACf,MAAM,CAAC,SAAS;IAChB,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK;IACtD,KAAK;CACN,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AARD,QAAA,WAAW,eAQV;AAEd;;;;;GAKG;AACH,MAAM,KAAK,GAAG,CAAC,GAAqB,EAAE,IAAW,EAAE,GAAQ,EAAQ,EAAE;IACnE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE;QACrB,6CAA6C;QAC7C,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QACnB,OAAO;KACR;IACD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;QACjB,6CAA6C;QAC7C,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;KACnB;IACD,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AAC1C,CAAC,CAAC;AAEK,MAAM,qBAAqB,GAAG,CAAC,oBAAoC,EAAqC,EAAE;IAG/G,MAAM,mBAAmB,GAAgE,EAAE,CAAC;IAE5F,oBAAoB;SACjB,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACb,IAAA,mBAAW,EAAC,IAAI,CAAC;QACjB,IAAI,CAAC,QAAQ,CAAC,sBAAsB;YAClC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,cAAc,EAAE;YACvD,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE,cAAc,EAAE,IAAI,EAAE;KAClE,CAAC;SACD,OAAO,CAAC,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,EAAE;QAChC,MAAM,cAAc,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,YAAY,GAAG,cAAc,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,iBAAiB,CAAC;QAClH,MAAM,YAAY,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtE,MAAM,QAAQ,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC;QACnC,MAAM,aAAa,GAAG,QAAQ,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/D,MAAM,QAAQ,GAAwB;YACpC,QAAQ;YACR,QAAQ;SACT,CAAC;QACF,MAAM,QAAQ,GAAG,GAAG,YAAY,IAAI,QAAQ,EAAE,CAAC;QAC/C,yHAAyH;QACzH,IAAI,QAAQ,IAAI,mBAAmB,IAAI,aAAa,IAAI,mBAAmB,CAAC,QAAQ,CAAC,EAAE;YACrF,KAAK,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,QAAQ,CAAC,CAAC;SAC/E;aAAM;YACL,MAAM,IAAI,GAAG;gBACX,gBAAgB,EAAE,cAAc,CAAC,CAAC,CAAC;gBACnC,iBAAiB,EAAE,cAAc,CAAC,CAAC,CAAC;gBACpC,QAAQ;gBACR,CAAC,YAAY,CAAC,EAAE,QAAQ;aACzB,CAAC;YACF,KAAK,CAAC,mBAAmB,EAAE,CAAC,QAAQ,EAAE,aAAa,CAAC,EAAE,IAAI,CAAC,CAAC;SAC7D;IACH,CAAC,CAAC,CAAC;IAEL,OAAO,MAAM,CAAC,OAAO,CAAC,mBAAmB,CAAC;SACvC,GAAG,CAAC,CAAC,CAAC,eAAe,EAAE,aAAa,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1C,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC;aACxC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;aACtC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC;QAC3B,YAAY,EAAE,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;KAC5C,CAAC,CAAC;SACF,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,EAAE,EAAE;QAC9C,IAAI,GAAG,CAAC,YAAY,CAAC,EAAE;YACrB,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC;SACzC;aAAM;YACL,GAAG,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;SAClC;QACD,OAAO,GAAG,CAAC;IACb,CAAC,EAAE,EAAuC,CAAC,CAAC;AAChD,CAAC,CAAC;AApDW,QAAA,qBAAqB,yBAoDhC","sourcesContent":["import { UserDefinedSlot, UserDefinedResolver } from '@aws-amplify/graphql-transformer-core';\nimport { FunctionSlot } from '../types';\n\n/**\n * Validate that only supported props are being passed into the funciton slots.\n * @param functionSlots the slot inputs to validate.\n */\nexport const validateFunctionSlots = (functionSlots: FunctionSlot[]): void => {\n  functionSlots.forEach(({ function: { responseMappingTemplate, requestMappingTemplate } }) => {\n    if (!requestMappingTemplate && !responseMappingTemplate) {\n      throw new Error('Expected at least one of either requestMappingTemplate or responseMappingTemplate');\n    }\n  });\n};\n\n/**\n * We'll partition any slots have both a request and response mapping template into two to make the existing system work.\n * @param functionSlots the possibly consolidated slots.\n * @returns no longer consolidated slots.\n */\nexport const separateSlots = (functionSlots: FunctionSlot[]): FunctionSlot[] =>\n  functionSlots.flatMap((slot) => {\n    if (slot.function.requestMappingTemplate && slot.function.responseMappingTemplate) {\n      return [\n        {\n          ...slot,\n          function: {\n            requestMappingTemplate: slot.function.requestMappingTemplate,\n          },\n        },\n        {\n          ...slot,\n          function: {\n            responseMappingTemplate: slot.function.responseMappingTemplate,\n          },\n        },\n      ];\n    }\n    return [slot];\n  });\n\n/**\n * Given a set of strongly typed input params, generate a valid transformer slot name.\n * @param params the slot configuration\n * @returns the slot id\n */\nexport const getSlotName = (params: FunctionSlot): string =>\n  [\n    params.typeName,\n    params.fieldName,\n    params.slotName,\n    params.slotIndex,\n    params.function.requestMappingTemplate ? 'req' : 'res',\n    'vtl',\n  ].join('.');\n\n/**\n * Utility to avoid using lodash.\n * @param obj the object to deeply set values in.\n * @param path the access path.\n * @param val the value to set.\n */\nconst setIn = (obj: Record<any, any>, path: any[], val: any): void => {\n  if (path.length === 1) {\n    // eslint-disable-next-line no-param-reassign\n    obj[path[0]] = val;\n    return;\n  }\n  if (!obj[path[0]]) {\n    // eslint-disable-next-line no-param-reassign\n    obj[path[0]] = {};\n  }\n  setIn(obj[path[0]], path.slice(1), val);\n};\n\nexport const parseUserDefinedSlots = (userDefinedTemplates: FunctionSlot[]): Record<string, UserDefinedSlot[]> => {\n  type ResolverKey = string;\n  type ResolverOrder = number;\n  const groupedResolversMap: Record<ResolverKey, Record<ResolverOrder, UserDefinedSlot>> = {};\n\n  userDefinedTemplates\n    .map((slot) => [\n      getSlotName(slot),\n      slot.function.requestMappingTemplate\n        ? slot.function.requestMappingTemplate.renderTemplate()\n        : slot.function.responseMappingTemplate?.renderTemplate() ?? '',\n    ])\n    .forEach(([fileName, template]) => {\n      const slicedSlotName = fileName.split('.');\n      const resolverType = slicedSlotName[slicedSlotName.length - 2] === 'res' ? 'responseResolver' : 'requestResolver';\n      const resolverName = [slicedSlotName[0], slicedSlotName[1]].join('.');\n      const slotName = slicedSlotName[2];\n      const resolverOrder = `order${Number(slicedSlotName[3]) || 0}`;\n      const resolver: UserDefinedResolver = {\n        fileName,\n        template,\n      };\n      const slotHash = `${resolverName}#${slotName}`;\n      // because a slot can have a request and response resolver, we need to group corresponding request and response resolvers\n      if (slotHash in groupedResolversMap && resolverOrder in groupedResolversMap[slotHash]) {\n        setIn(groupedResolversMap, [slotHash, resolverOrder, resolverType], resolver);\n      } else {\n        const slot = {\n          resolverTypeName: slicedSlotName[0],\n          resolverFieldName: slicedSlotName[1],\n          slotName,\n          [resolverType]: resolver,\n        };\n        setIn(groupedResolversMap, [slotHash, resolverOrder], slot);\n      }\n    });\n\n  return Object.entries(groupedResolversMap)\n    .map(([resolverNameKey, numberedSlots]) => ({\n      orderedSlots: Object.entries(numberedSlots)\n        .sort(([i], [j]) => i.localeCompare(j))\n        .map(([_, slot]) => slot),\n      resolverName: resolverNameKey.split('#')[0],\n    }))\n    .reduce((acc, { orderedSlots, resolverName }) => {\n      if (acc[resolverName]) {\n        acc[resolverName].push(...orderedSlots);\n      } else {\n        acc[resolverName] = orderedSlots;\n      }\n      return acc;\n    }, {} as Record<string, UserDefinedSlot[]>);\n};\n"]}