@luvio/compiler 0.95.0 → 0.97.1

package/dist/codegen/graphql/type/generateTypeUtil.js

@@ -18,34 +18,34 @@ function generateTypeUtil(graphqlResource, metadata, importContext) {
         throw new Error('Invalid GraphQL Schema. You must include a Query Type.');
     }
     const queryTypeName = queryType.name;
-    const queryTransformerImport = importContext.importGraphQLArtifact('types', queryTypeName, 'getQueryTransformerForField');
-    const queryTransformerForTypeImport = importContext.importGraphQLArtifact('types', queryTypeName, 'getQueryTransformerForType');
-    const arrayIsArrayUtilsIdentifier = importContext.importTypeUtil('ArrayIsArray');
-    // TODO: W-11246519 improve readability of the applyMinimumFields function by replacing the AST visitor with
-    // manual node traversal
+    const getQueryTransformHelperForFieldImport = importContext.importGraphQLArtifact('types', queryTypeName, 'getQueryTransformHelperForField');
+    const getQueryTransformHelperForTypeImport = importContext.importGraphQLArtifact('types', queryTypeName, 'getQueryTransformHelperForType');
     return (0, imports_1.resolveImports)((0, deindent_1.default) `
         export type ${constants_3.GRAPHQL_VARIABLES_IDENTIFIER} = Record<string, any>;
         export type ${constants_3.GRAPHQL_FRAGMENT_MAP_IDENTIFIER} = Record<string, ${constants_2.LUVIO_GRAPHQL_FRAGMENT_DEFINITION_NODE_IMPORT}>;
         export interface ${constants_3.GRAPHQL_STATE_INTERFACE_IDENTIFIER}<D = unknown> {
             data: D,
-            variables: ${constants_3.GRAPHQL_VARIABLES_IDENTIFIER},
-            fragments: ${constants_3.GRAPHQL_FRAGMENT_MAP_IDENTIFIER},
             path: ${constants_1.ADAPTER_INGEST_PATH_INTERFACE_IDENTIFIER},
+            variables: ${constants_3.GRAPHQL_VARIABLES_IDENTIFIER},
+            fragments: ${constants_3.GRAPHQL_FRAGMENT_MAP_IDENTIFIER}
+        }
+        
+        export interface ${constants_3.GRAPHQL_INGEST_STATE_INTERFACE_IDENTIFIER}<D> extends ${constants_3.GRAPHQL_STATE_INTERFACE_IDENTIFIER}<D> {
             ${constants_2.LUVIO_IDENTIFIER}: ${constants_2.LUVIO_IMPORT},
             ${constants_2.LUVIO_STORE_IDENTIFIER}: ${constants_2.LUVIO_STORE_IMPORT},
             ${constants_3.TIMESTAMP_IDENTIFIER}: number
         };
 
-        export interface QueryTransformerFunction {
-            (fieldId: string): ${constants_3.QUERY_TRANSFORMER_IDENTIFIER} | undefined;
+        export interface GetQueryTransformHelperFunction {
+            (fieldId: string): ${constants_3.QUERY_TRANSFORM_HELPER_IDENTIFIER} | undefined;
         }
 
         export interface GetMinimumFieldsFunction {
             (): ${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[];
         }
 
-        export interface ${constants_3.QUERY_TRANSFORMER_IDENTIFIER} {
-            ${constants_3.GET_QUERY_TRANSFORMER_FOR_FIELD_IDENTIFIER}: QueryTransformerFunction,
+        export interface ${constants_3.QUERY_TRANSFORM_HELPER_IDENTIFIER} {
+            ${constants_3.GET_QUERY_TRANSFORM_HELPER_FOR_FIELD_IDENTIFIER}: GetQueryTransformHelperFunction,
             ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}: GetMinimumFieldsFunction
         }
 
@@ -56,7 +56,7 @@ function generateTypeUtil(graphqlResource, metadata, importContext) {
         }
 
         export function ${constants_3.SERIALIZE_FIELD_ARGUMENTS_IDENTIFIER}(argumentNodes: Readonly<${constants_2.LUVIO_GRAPHQL_ARGUMENT_NODE_IMPORT}[]>, variables: ${constants_3.GRAPHQL_VARIABLES_IDENTIFIER}): string {
-            const mutableArgumentNodes = Object.assign([], argumentNodes);
+            const mutableArgumentNodes = Object.assign([] as ${constants_2.LUVIO_GRAPHQL_ARGUMENT_NODE_IMPORT}[], argumentNodes);
             return \`args__(\${mutableArgumentNodes.sort(
                 (a, b) =>{
                     const aName = a.name.value.toUpperCase()
@@ -80,19 +80,19 @@ function generateTypeUtil(graphqlResource, metadata, importContext) {
                 case("StringValue"):
                     return valueNode.value
                 case("ListValue"):
-                    const mutableValueNodeList = Object.assign([], valueNode.values);
+                    const mutableValueNodeList = Object.assign([] as ${constants_2.LUVIO_GRAPHQL_VALUE_NODE_IMPORT}[], valueNode.values);
                     return mutableValueNodeList.sort(
                         (a, b) =>{
-                            const aName = a.name.value.toUpperCase()
-                            const bName = b.name.value.toUpperCase()
-                            return aName < bName ? -1 : (aName > bName) ? 1 : 0
+                            const aVal = serializeValueNode(a, variables).toUpperCase()
+                            const bVal = serializeValueNode(b, variables).toUpperCase()
+                            return aVal < bVal ? -1 : (aVal > bVal) ? 1 : 0
                         }).map((val, i) => serializeValueNode(val, variables) + \`[\${i}]\`).join(',')
                 case("Variable"):
                     return variables[valueNode.name.value] + "" //TODO: Is this correct serialization for object type variables?
                 case("NullValue"):
                     return "null";
                 case("ObjectValue"):
-                    const mutableFieldNodeList = Object.assign([], valueNode.fields);
+                    const mutableFieldNodeList = Object.assign([] as ${constants_2.LUVIO_GRAPHQL_OBJECT_FIELD_NODE_IMPORT}[], valueNode.fields);
                     return mutableFieldNodeList.sort(
                         (a, b) =>{
                             const aName = a.name.value.toUpperCase()
@@ -105,104 +105,65 @@ function generateTypeUtil(graphqlResource, metadata, importContext) {
         export const TTL = ${(0, utils_1.getShapeTtl)(metadata.rootTtl, (_a = graphqlResource.returnShape) === null || _a === void 0 ? void 0 : _a.id, metadata.shapeTtls)};
 
         export function ${constants_3.APPLY_MINIMUM_FIELDS_TO_QUERY_IDENTIFIER} (query: ${constants_2.LUVIO_GRAPHQL_DOCUMENT_NODE_IMPORT}): ${constants_2.LUVIO_GRAPHQL_DOCUMENT_NODE_IMPORT} {
-            const queryTransformerStack: ${constants_3.QUERY_TRANSFORMER_IDENTIFIER}[] = [];
-            const visitor: ${constants_2.LUVIO_GRAPHQL_AST_VISITOR_IMPORT} = {
-                OperationDefinition: {
-                    enter(node) {
-                        if (node.operation === 'query') {
-                            queryTransformerStack.push({
-                                ${constants_3.GET_QUERY_TRANSFORMER_FOR_FIELD_IDENTIFIER}: ${queryTransformerImport},
-                                ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}: () => {return []}
-                            });
-                        }
-                    },
-                },
-                Field: {
-                    enter(node) {
-                        if (node.selectionSet?.selections !== undefined) {
-                            const { ${constants_3.GET_QUERY_TRANSFORMER_FOR_FIELD_IDENTIFIER} } = queryTransformerStack[queryTransformerStack.length - 1];
-                            const queryTransformer = ${constants_3.GET_QUERY_TRANSFORMER_FOR_FIELD_IDENTIFIER}(node.name.value);
-                            if (queryTransformer === undefined) {
-                                throw new Error("Invalid field in query '" + node.name.value
-                                + "' at line: " + node.name.loc?.startToken.line
-                                + " column: " + node.name.loc?.startToken.column);
-                            }
-                            queryTransformerStack.push(queryTransformer);
-                        }
-                    },
-                    leave(node) {
-                        if (node.selectionSet?.selections !== undefined) {
-                            queryTransformerStack.pop();
-                        }
-                    }
-                },
-                InlineFragment: {
-                    enter(node, _key, parentFields) {
-                        if (node.typeCondition !== undefined && node.typeCondition !== null) {
-                            const queryTransformer = ${queryTransformerForTypeImport}(node.typeCondition.name.value)
-                            if (queryTransformer === undefined) {
-                                throw new Error("Invalid type in query fragment '" + node.typeCondition.name.value
-                                    + "' at line: " + node.typeCondition.name.loc?.startToken.line
-                                    + " column: " + node.typeCondition.name.loc?.startToken.column);
-                            }
-                            const { ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER} } = queryTransformer;
+            query.definitions.forEach(queryDefinitionNode => {
+                if (queryDefinitionNode.kind === 'OperationDefinition' && queryDefinitionNode.operation === 'query') {
+                    injectSelectionSet(queryDefinitionNode.selectionSet, {
+                        ${constants_3.GET_QUERY_TRANSFORM_HELPER_FOR_FIELD_IDENTIFIER}: ${getQueryTransformHelperForFieldImport},
+                        ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}: () => { return [] }
+                    });
+                }
+            })
+            return query;
+        }        
 
-                            // create a wrapper for the getMinimumFields function that filters
-                            // out any fields already present via encapsulation in the parent fields
-                            let wrappedGetMinimumFields = ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER};
-                            if (${arrayIsArrayUtilsIdentifier}(parentFields)) {
-                                wrappedGetMinimumFields = ():${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[] => {
-                                    return ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}().filter((field) => {
-                                        const fieldIsAlreadyPresent = parentFields.some(parentField => {
-                                            return parentField.kind == 'Field' && parentField.name.value === field.name.value;
-                                        });
-                                        return !fieldIsAlreadyPresent;
-                                    });
-                                };
-                            }
-                            queryTransformerStack.push({
-                                ...queryTransformer,
-                                ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}: wrappedGetMinimumFields
-                            });
-                        }
-                    },
-                    leave(node) {
-                        if (node.typeCondition !== undefined) {
-                            queryTransformerStack.pop();
-                        }
+        export function injectSelectionSet (selectionSetNode: ${constants_2.LUVIO_GRAPHQL_SELECTION_SET_NODE_IMPORT}, queryTransformHelper: ${constants_3.QUERY_TRANSFORM_HELPER_IDENTIFIER}|undefined) {
+            const { selections } = selectionSetNode;
+            if (queryTransformHelper === undefined ||
+                queryTransformHelper === null ||
+                selections === undefined ||
+                selections === null) {
+                return;
+            }
+        
+            const { getMinimumFields, getQueryTransformHelperForField } = queryTransformHelper;
+        
+            // Call the function to get the minimum fields for this node, filtering out any
+            // fields that are already present in the selection.
+            const minimumFields = getMinimumFields().filter(field => {
+                const fieldIsAlreadyPresent = selections.some(selection => {
+                    return selection.kind === 'Field' && (selection.name.value === field.name.value);
+                });
+                return !fieldIsAlreadyPresent;
+            });
+        
+            selectionSetNode.selections = [...selections, ...minimumFields];
+        
+            selectionSetNode.selections.forEach(selection => {
+                if (selection.kind === 'Field' && selection.selectionSet) {
+                    const fieldTransformHelper = getQueryTransformHelperForField(selection.name.value);
+                    injectSelectionSet(selection.selectionSet, fieldTransformHelper);
+                }
+                if (selection.kind === 'InlineFragment' && selection.selectionSet && selection.typeCondition) {
+                    // create a wrapper for the getMinimumFields function that filters
+                    // out any fields already present via encapsulation in the parent fields
+                    const fieldTransformHelper = ${getQueryTransformHelperForTypeImport}(selection.typeCondition.name.value);
+                    if (fieldTransformHelper === undefined) {
+                        return;
                     }
-                },
-                SelectionSet: {
-                    enter(node, _key, _parent) {
-                        // No changes if no selections.
-                        const { selections } = node;
-                        if (!selections) {
-                            return;
-                        }
-
-                        // This node is always entered after a Field node.  A query transformer for this node was pushed
-                        // onto the stack when that Field node was entered.  The query transformer provides a function
-                        // to get the minimum fields for this node.
-                        const { ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER} } = queryTransformerStack[queryTransformerStack.length - 1];
-
-                        // Call the function to get the minimum fields for this node, filtering out any
-                        // fields that are already present in the selection.
-                        const minimumFields = ${constants_3.GET_MINIMUM_FIELDS_IDENTIFIER}().filter(field => {
-                            const fieldIsAlreadyPresent = selections.some(selection => {
-                                return selection.kind === 'Field' && (selection.name.value === field.name.value);
+                    const wrappedGetMinimumFields = ():${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[] => {
+                        return fieldTransformHelper.getMinimumFields().filter((field) => {
+                            const fieldIsAlreadyPresent = selectionSetNode.selections.some(parentField => {
+                                return parentField.kind === 'Field' && parentField.name.value === field.name.value;
                             });
                             return !fieldIsAlreadyPresent;
                         });
-
-                        // Return a new SelectionSet including minimum fields
-                        return {
-                            ...node,
-                            selections: [...selections, ...minimumFields],
-                        };
-                    },
-                },
-            };
-            return ${constants_2.LUVIO_GRAPHQL_VISIT_IMPORT}(query, visitor);
+                    };
+                    injectSelectionSet(selection.selectionSet, {
+                        ...fieldTransformHelper,
+                        getMinimumFields: wrappedGetMinimumFields
+                    });
+                }
+            })
         }
 
         export function ${constants_3.GET_REQUESTED_FIELD_IDENTIFIER}(responseDataFieldName: string, requestedFields: ${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[]): ${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT} | undefined {
@@ -216,12 +177,12 @@ function generateTypeUtil(graphqlResource, metadata, importContext) {
         }
 
         export function ${constants_3.GET_REQUESTED_FIELDS_FOR_TYPE_IDENTIFIER}(typename: string, selectionSet: ${constants_2.LUVIO_GRAPHQL_SELECTION_SET_NODE_IMPORT}, namedFragmentsMap: ${constants_3.GRAPHQL_FRAGMENT_MAP_IDENTIFIER}): ${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[] {
-            const selections = [];
+            const selections: ${constants_2.LUVIO_GRAPHQL_FIELD_NODE_IMPORT}[] = [];
             selectionSet.selections.forEach(selection => { 
                 if(selection.kind === "Field") {
                     selections.push(selection);
                 }
-                if(selection.kind === "InlineFragment" && selection.typeCondition.name.value === typename) {
+                if(selection.kind === "InlineFragment" && selection.typeCondition?.name.value === typename) {
                     ${constants_3.GET_REQUESTED_FIELDS_FOR_TYPE_IDENTIFIER}(typename, selection.selectionSet, namedFragmentsMap)
                         .forEach(fragmentFieldSelection => selections.push(fragmentFieldSelection));
                 }

package/dist/codegen/graphql/type/generateTypeUtil.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateTypeUtil.js","sourceRoot":"","sources":["../../../../src/codegen/graphql/type/generateTypeUtil.ts"],"names":[],"mappings":";;;;;;AAAA,uEAA+C;AAC/C,oDAAwD;AAExD,oCAAuC;AAGvC,uDAAmF;AACnF,sDAagC;AAChC,2CAcqB;AAErB,SAAgB,gBAAgB,CAC5B,eAAgC,EAChC,QAAgC,EAChC,aAA4B;;IAE5B,kHAAkH;IAClH,MAAM,SAAS,GAAG,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACnE,IAAI,CAAC,SAAS,EAAE;QACZ,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC7E;IACD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAI,CAAC;IACrC,MAAM,sBAAsB,GAAG,aAAa,CAAC,qBAAqB,CAC9D,OAAO,EACP,aAAa,EACb,6BAA6B,CAChC,CAAC;IACF,MAAM,6BAA6B,GAAG,aAAa,CAAC,qBAAqB,CACrE,OAAO,EACP,aAAa,EACb,4BAA4B,CAC/B,CAAC;IAEF,MAAM,2BAA2B,GAAG,aAAa,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;IAEjF,4GAA4G;IAC5G,wBAAwB;IACxB,OAAO,IAAA,wBAAc,EAAC,IAAA,kBAAQ,EAAA;sBACZ,wCAA4B;sBAC5B,2CAA+B,qBAAqB,yDAA6C;2BAC5F,8CAAkC;;yBAEpC,wCAA4B;yBAC5B,2CAA+B;oBACpC,oDAAwC;cAC9C,4BAAgB,KAAK,wBAAY;cACjC,kCAAsB,KAAK,8BAAkB;cAC7C,gCAAoB;;;;iCAID,wCAA4B;;;;kBAI3C,2CAA+B;;;2BAGtB,wCAA4B;cACzC,sDAA0C;cAC1C,yCAA6B;;;0BAGjB,kCAAsB;;;;;;0BAMtB,gDAAoC,4BAA4B,8CAAkC,mBAAmB,wCAA4B;;;;;;;;;;kDAUzH,8CAAkC,gBAAgB,wCAA4B;;;;;iDAK/E,2CAA+B,gBAAgB,wCAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgC/F,IAAA,mBAAW,EAC5B,QAAQ,CAAC,OAAO,EAChB,MAAA,eAAe,CAAC,WAAW,0CAAE,EAAE,EAC/B,QAAQ,CAAC,SAAS,CACrB;;0BAEiB,oDAAwC,YAAY,8CAAkC,MAAM,8CAAkC;2CAC7G,wCAA4B;6BAC1C,4CAAgC;;;;;kCAK3B,sDAA0C,KAAK,sBAAsB;kCACrE,yCAA6B;;;;;;;;sCAQzB,sDAA0C;uDACzB,sDAA0C;;;;;;;;;;;;;;;;;;uDAkB1C,6BAA6B;;;;;;sCAM9C,yCAA6B;;;;4DAIP,yCAA6B;kCACvD,2BAA2B;+DACE,2CAA+B;6CACjD,yCAA6B;;;;;;;;;;kCAUxC,yCAA6B;;;;;;;;;;;;;;;;;;;;;kCAqB7B,yCAA6B;;;;gDAIf,yCAA6B;;;;;;;;;;;;;;;qBAexD,sCAA0B;;;0BAGrB,0CAA8B,oDAAoD,2CAA+B,QAAQ,2CAA+B;;;;0BAIxJ,mDAAuC,WAAW,2CAA+B,gBAAgB,wCAA4B;;qGAElD,gDAAoC;;;;0BAI/G,oDAAwC,oCAAoC,mDAAuC,wBAAwB,2CAA+B,MAAM,2CAA+B;;;;;;;sBAOnN,oDAAwC;;;;;;0BAMpC,oDAAwC;;;;;;;KAO7D,CAAC,CAAC;AACP,CAAC;AAnPD,4CAmPC"}
+{"version":3,"file":"generateTypeUtil.js","sourceRoot":"","sources":["../../../../src/codegen/graphql/type/generateTypeUtil.ts"],"names":[],"mappings":";;;;;;AAAA,uEAA+C;AAC/C,oDAAwD;AAExD,oCAAuC;AAGvC,uDAAmF;AACnF,sDAYgC;AAChC,2CAeqB;AAErB,SAAgB,gBAAgB,CAC5B,eAAgC,EAChC,QAAgC,EAChC,aAA4B;;IAE5B,kHAAkH;IAClH,MAAM,SAAS,GAAG,eAAe,CAAC,UAAU,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;IACnE,IAAI,CAAC,SAAS,EAAE;QACZ,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;KAC7E;IACD,MAAM,aAAa,GAAG,SAAS,CAAC,IAAI,CAAC;IACrC,MAAM,qCAAqC,GAAG,aAAa,CAAC,qBAAqB,CAC7E,OAAO,EACP,aAAa,EACb,iCAAiC,CACpC,CAAC;IACF,MAAM,oCAAoC,GAAG,aAAa,CAAC,qBAAqB,CAC5E,OAAO,EACP,aAAa,EACb,gCAAgC,CACnC,CAAC;IAEF,OAAO,IAAA,wBAAc,EAAC,IAAA,kBAAQ,EAAA;sBACZ,wCAA4B;sBAC5B,2CAA+B,qBAAqB,yDAA6C;2BAC5F,8CAAkC;;oBAEzC,oDAAwC;yBACnC,wCAA4B;yBAC5B,2CAA+B;;;2BAG7B,qDAAyC,eAAe,8CAAkC;cACvG,4BAAgB,KAAK,wBAAY;cACjC,kCAAsB,KAAK,8BAAkB;cAC7C,gCAAoB;;;;iCAID,6CAAiC;;;;kBAIhD,2CAA+B;;;2BAGtB,6CAAiC;cAC9C,2DAA+C;cAC/C,yCAA6B;;;0BAGjB,kCAAsB;;;;;;0BAMtB,gDAAoC,4BAA4B,8CAAkC,mBAAmB,wCAA4B;+DAC5G,8CAAkC;;;;;;;;;kDAS/C,8CAAkC,gBAAgB,wCAA4B;;;;;iDAK/E,2CAA+B,gBAAgB,wCAA4B;;;;;;;;;;uEAUrD,2CAA+B;;;;;;;;;;;;uEAY/B,kDAAsC;;;;;;;;;;6BAUhF,IAAA,mBAAW,EAC5B,QAAQ,CAAC,OAAO,EAChB,MAAA,eAAe,CAAC,WAAW,0CAAE,EAAE,EAC/B,QAAQ,CAAC,SAAS,CACrB;;0BAEiB,oDAAwC,YAAY,8CAAkC,MAAM,8CAAkC;;;;0BAI9H,2DAA+C,KAAK,qCAAqC;0BACzF,yCAA6B;;;;;;;gEAOS,mDAAuC,2BAA2B,6CAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDA8BhH,oCAAoC;;;;yDAI9B,2CAA+B;;;;;;;;;;;;;;;;0BAgB9D,0CAA8B,oDAAoD,2CAA+B,QAAQ,2CAA+B;;;;0BAIxJ,mDAAuC,WAAW,2CAA+B,gBAAgB,wCAA4B;;qGAElD,gDAAoC;;;;0BAI/G,oDAAwC,oCAAoC,mDAAuC,wBAAwB,2CAA+B,MAAM,2CAA+B;gCACzM,2CAA+B;;;;;;sBAMzC,oDAAwC;;;;;;0BAMpC,oDAAwC;;;;;;;KAO7D,CAAC,CAAC;AACP,CAAC;AA3MD,4CA2MC"}

package/dist/codegen/graphql/type/index.js

@@ -13,6 +13,8 @@ const merge_1 = require("./merge");
 const imports_1 = require("../../../utils/imports");
 const select_1 = require("./select");
 const query_transformer_1 = require("./query-transformer");
+const type_cache_keys_1 = require("./type-cache-keys");
+const type_from_field_1 = require("./type-from-field");
 function generateType(graphqlDsl, graphqlTypeName, def, importContext, metadata, modelInfo) {
     return (0, imports_1.resolveImports)((0, deindent_1.default) `
         export const name = '${graphqlTypeName}';
@@ -23,6 +25,8 @@ function generateType(graphqlDsl, graphqlTypeName, def, importContext, metadata,
         ${(0, ingest_1.generateIngest)(graphqlDsl, graphqlTypeName, def, importContext, metadata, modelInfo)}
         ${(0, select_1.generateSelect)(graphqlDsl, graphqlTypeName, def, importContext, metadata)}
         ${(0, query_transformer_1.generate)(graphqlDsl, graphqlTypeName, def, importContext, metadata)}
+        ${(0, type_cache_keys_1.generateGetTypeCacheKeys)(graphqlDsl, graphqlTypeName, def, importContext, metadata)}
+        ${(0, type_from_field_1.generateGetFieldType)(graphqlDsl, def, importContext, metadata)}
     `);
 }
 exports.generateType = generateType;

package/dist/codegen/graphql/type/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/codegen/graphql/type/index.ts"],"names":[],"mappings":";;;;;;AAAA,uEAA+C;AAC/C,+BAAoC;AACpC,2CAAiD;AACjD,qCAA0C;AAC1C,+BAAoC;AACpC,mCAAwC;AACxC,oDAAwD;AAKxD,qCAA0C;AAC1C,2DAA2E;AAG3E,SAAgB,YAAY,CACxB,UAA2B,EAC3B,eAAuB,EACvB,GAA6B,EAC7B,aAA4B,EAC5B,QAAgC,EAChC,SAAoB;IAEpB,OAAO,IAAA,wBAAc,EAAC,IAAA,kBAAQ,EAAA;+BACH,eAAe;UACpC,IAAA,iBAAW,EAAC,UAAU,EAAE,eAAe,CAAC;UACxC,IAAA,8BAAkB,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UAC7E,IAAA,iBAAW,EAAC,GAAG,EAAE,aAAa,EAAE,UAAU,CAAC,UAAU,CAAC;UACtD,IAAA,qBAAa,EAAC,aAAa,CAAC;UAC5B,IAAA,uBAAc,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,CAAC;UACpF,IAAA,uBAAc,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UACzE,IAAA,4BAAwB,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;KACxF,CAAC,CAAC;AACP,CAAC;AAlBD,oCAkBC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/codegen/graphql/type/index.ts"],"names":[],"mappings":";;;;;;AAAA,uEAA+C;AAC/C,+BAAoC;AACpC,2CAAiD;AACjD,qCAA0C;AAC1C,+BAAoC;AACpC,mCAAwC;AACxC,oDAAwD;AAKxD,qCAA0C;AAC1C,2DAA2E;AAE3E,uDAA6D;AAC7D,uDAAyD;AAEzD,SAAgB,YAAY,CACxB,UAA2B,EAC3B,eAAuB,EACvB,GAA6B,EAC7B,aAA4B,EAC5B,QAAgC,EAChC,SAAoB;IAEpB,OAAO,IAAA,wBAAc,EAAC,IAAA,kBAAQ,EAAA;+BACH,eAAe;UACpC,IAAA,iBAAW,EAAC,UAAU,EAAE,eAAe,CAAC;UACxC,IAAA,8BAAkB,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UAC7E,IAAA,iBAAW,EAAC,GAAG,EAAE,aAAa,EAAE,UAAU,CAAC,UAAU,CAAC;UACtD,IAAA,qBAAa,EAAC,aAAa,CAAC;UAC5B,IAAA,uBAAc,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,SAAS,CAAC;UACpF,IAAA,uBAAc,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UACzE,IAAA,4BAAwB,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UACnF,IAAA,0CAAwB,EAAC,UAAU,EAAE,eAAe,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;UACnF,IAAA,sCAAoB,EAAC,UAAU,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,CAAC;KACnE,CAAC,CAAC;AACP,CAAC;AApBD,oCAoBC"}

package/dist/codegen/graphql/type/ingest.d.ts

@@ -4,7 +4,7 @@ import type { NormalizableTypes } from '../utils';
 import type { LuvioGraphQLDSL } from '../../../intermediate/graphql';
 import type { GraphQLCodegenMetadata } from '../source-printer';
 import type { ModelInfo } from '../../../main';
-export declare function ingestNamedType(field: FieldDefinitionNode, typeNode: NamedTypeNode, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
-export declare function ingestListType(field: FieldDefinitionNode, typeNode: ListTypeNode, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
-export declare function ingestType(field: FieldDefinitionNode, typeNode: TypeNode, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
+export declare function ingestNamedType(graphqlField: FieldDefinitionNode, typeNode: NamedTypeNode, ramlFieldName: string | undefined, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
+export declare function ingestListType(graphqlField: FieldDefinitionNode, typeNode: ListTypeNode, ramlFieldName: string | undefined, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
+export declare function ingestType(graphqlField: FieldDefinitionNode, typeNode: TypeNode, ramlFieldName: string | undefined, importContext: ImportContext, normalizableTypeMap: NormalizableTypes): string;
 export declare function generateIngest(graphqlDsl: LuvioGraphQLDSL, graphqlTypeName: string, def: ObjectTypeDefinitionNode, importContext: ImportContext, _metadata: GraphQLCodegenMetadata, modelInfo: ModelInfo): string;

package/dist/codegen/graphql/type/ingest.js

@@ -8,54 +8,71 @@ const deindent_1 = __importDefault(require("../../../utils/deindent"));
 const constants_1 = require("../../shared/constants");
 const utils_1 = require("../utils");
 const utils_2 = require("./utils");
+const convert_1 = require("./convert");
 const constants_2 = require("./constants");
 const interface_1 = require("./interface");
 const types_1 = require("../utils/types");
 const REQUESTED_FIELDS_IDENTIFIER = 'requestedFields';
-function ingestNamedType(field, typeNode, importContext, normalizableTypeMap) {
+function generateIngestScalarField(graphqlFieldName, ramlFieldName) {
+    // omit scalar fields that are mapped to RAML fields
+    if (ramlFieldName === undefined) {
+        return (0, deindent_1.default) `
+            case '${graphqlFieldName}': {
+                ${constants_2.SINK_IDENTIFIER}[${constants_2.FIELD_KEY_IDENTIFIER}] = ${constants_2.FIELD_DATA_IDENTIFIER};
+                break;
+            }
+        `;
+    }
+    return '';
+}
+function ingestNamedType(graphqlField, typeNode, ramlFieldName, importContext, normalizableTypeMap) {
     const graphqlTypeName = (0, utils_1.resolveTypeName)(typeNode);
     const { importGraphQLArtifact } = importContext;
     const isScalar = normalizableTypeMap[graphqlTypeName] === undefined;
-    const fieldName = field.name.value;
+    const graphqlFieldName = graphqlField.name.value;
     if (isScalar) {
-        return generateIngestScalarField(fieldName);
+        return generateIngestScalarField(graphqlFieldName, ramlFieldName);
     }
     const typeNameIngestImport = importGraphQLArtifact('types', graphqlTypeName, constants_2.TYPE_INGEST_IDENTIFIER);
-    const fieldStateIdentifier = `${fieldName}State`;
+    const graphqlStateInterface = importGraphQLArtifact('types', constants_2.TYPE_UTIL_IDENTIFIER, constants_2.GRAPHQL_INGEST_STATE_INTERFACE_IDENTIFIER);
+    const typeNamePartialInterfaceImport = importGraphQLArtifact('types', graphqlTypeName, interface_1.PARTIAL_INTERFACE_IDENTIFIER);
+    const fieldStateIdentifier = `${graphqlFieldName}State`;
     return (0, deindent_1.default) `
-        case '${fieldName}': {
+        case '${graphqlFieldName}': {
             const ${fieldStateIdentifier} = {
                 ...state,
                 path: {
                     parent: null,
-                    propertyName: ${constants_2.FIELD_KEY_IDENTIFIER},
+                    propertyName: null,
                     fullPath: key + '__' + ${constants_2.FIELD_KEY_IDENTIFIER}
                 },
                 data: ${constants_2.FIELD_DATA_IDENTIFIER},
             };
-            dataSink[${constants_2.FIELD_KEY_IDENTIFIER}] = ${typeNameIngestImport}(
+            ${constants_2.SINK_IDENTIFIER}[${constants_2.FIELD_KEY_IDENTIFIER}] = ${typeNameIngestImport}(
                 ${constants_2.REQUESTED_FIELD_IDENTIFIER},
-                ${fieldStateIdentifier}
+                ${fieldStateIdentifier} as ${graphqlStateInterface}<${typeNamePartialInterfaceImport}>
             ) as any;
             break;
         }
     `;
 }
 exports.ingestNamedType = ingestNamedType;
-function ingestListType(field, typeNode, importContext, normalizableTypeMap) {
+function ingestListType(graphqlField, typeNode, ramlFieldName, importContext, normalizableTypeMap) {
     const { importGraphQLArtifact } = importContext;
-    const fieldName = field.name.value;
+    const graphqlFieldName = graphqlField.name.value;
     const graphqlTypeName = (0, utils_1.resolveTypeName)(typeNode);
-    const fullPathIdentifier = `fullPath__${fieldName}`;
-    const typeDefinition = normalizableTypeMap[graphqlTypeName];
-    const collectionIdentifier = `${fieldName}__items`;
+    const fullPathIdentifier = `fullPath__${graphqlFieldName}`;
+    const collectionIdentifier = `${graphqlFieldName}__items`;
     // Non-normalizable types
-    if (typeDefinition === undefined) {
-        return generateIngestScalarField(fieldName);
+    const isScalar = normalizableTypeMap[graphqlTypeName] === undefined;
+    if (isScalar) {
+        return generateIngestScalarField(graphqlFieldName, ramlFieldName);
     }
     const typeNameIngestImport = importGraphQLArtifact('types', graphqlTypeName, constants_2.TYPE_INGEST_IDENTIFIER);
+    const graphqlStateInterface = importGraphQLArtifact('types', constants_2.TYPE_UTIL_IDENTIFIER, constants_2.GRAPHQL_INGEST_STATE_INTERFACE_IDENTIFIER);
+    const typeNamePartialInterfaceImport = importGraphQLArtifact('types', graphqlTypeName, interface_1.PARTIAL_INTERFACE_IDENTIFIER);
     return (0, deindent_1.default) `
-        case '${fieldName}': {
+        case '${graphqlFieldName}': {
             const ${collectionIdentifier}: ${constants_1.LUVIO_STORE_LINK_IMPORT}[] = [];
             const ${fullPathIdentifier} = \`\${key}__\${${constants_2.FIELD_KEY_IDENTIFIER}}\`;
             for(let i = 0, len = ${constants_2.FIELD_DATA_IDENTIFIER}.length; i < len; i++) {
@@ -65,58 +82,47 @@ function ingestListType(field, typeNode, importContext, normalizableTypeMap) {
                     ...state,
                     path: {
                         parent: null,
-                        propertyName: i,
+                        propertyName: null,
                         fullPath: ${fullPathIdentifier} + i
                     },
                     data: item,
                 };
                 ${collectionIdentifier}[i] = ${typeNameIngestImport}(
                     ${constants_2.REQUESTED_FIELD_IDENTIFIER},
-                    itemState
-                )
+                    itemState as ${graphqlStateInterface}<${typeNamePartialInterfaceImport}>
+                ) as any;
             }
-            dataSink[${constants_2.FIELD_KEY_IDENTIFIER}] = ${collectionIdentifier};
+            ${constants_2.SINK_IDENTIFIER}[${constants_2.FIELD_KEY_IDENTIFIER}] = ${collectionIdentifier};
             break;
         }
     `;
 }
 exports.ingestListType = ingestListType;
-function generateIngestScalarField(fieldName) {
-    return (0, deindent_1.default) `
-        case '${fieldName}': {
-            dataSink[${constants_2.FIELD_KEY_IDENTIFIER}] = ${constants_2.FIELD_DATA_IDENTIFIER};
-            break;
-        }
-    `;
-}
-function ingestType(field, typeNode, importContext, normalizableTypeMap) {
-    if (field === undefined) {
+function ingestType(graphqlField, typeNode, ramlFieldName, importContext, normalizableTypeMap) {
+    if (graphqlField === undefined) {
         return '';
     }
     switch (typeNode.kind) {
         case 'NamedType':
-            return ingestNamedType(field, typeNode, importContext, normalizableTypeMap);
+            return ingestNamedType(graphqlField, typeNode, ramlFieldName, importContext, normalizableTypeMap);
         case 'ListType':
-            return ingestListType(field, typeNode, importContext, normalizableTypeMap);
+            return ingestListType(graphqlField, typeNode, ramlFieldName, importContext, normalizableTypeMap);
         default:
-            return ingestType(field, typeNode.type, importContext, normalizableTypeMap);
+            return ingestType(graphqlField, typeNode.type, ramlFieldName, importContext, normalizableTypeMap);
     }
 }
 exports.ingestType = ingestType;
 function generateObjectTypeIngest(graphqlDsl, graphqlTypeName, importContext, def, normalizableTypeMap) {
-    const { typeNameToExtensions } = graphqlDsl;
-    const fields = (0, types_1.getObjectFields)(def);
-    const fieldIngestStatements = fields
-        .filter((field) => field.type !== undefined)
-        .map((field) => {
-        // omit the fields that are mapped to RAML fields and delegate to RAML ingestion
-        const graphqlFieldName = field.name.value;
+    const graphqlFields = (0, types_1.getObjectFields)(def);
+    const fieldIngestStatements = graphqlFields
+        .filter((graphqlField) => graphqlField.type !== undefined)
+        .map((graphqlField) => {
+        const { typeNameToExtensions } = graphqlDsl;
+        const graphqlFieldName = graphqlField.name.value;
         const ramlFieldName = (0, utils_2.getRamlFieldName)(typeNameToExtensions, graphqlTypeName, graphqlFieldName);
-        if (ramlFieldName !== undefined) {
-            return '';
-        }
-        return ingestType(field, field.type, importContext, normalizableTypeMap);
-    });
+        return ingestType(graphqlField, graphqlField.type, ramlFieldName, importContext, normalizableTypeMap);
+    })
+        .filter((fieldIngestStatement) => fieldIngestStatement !== '');
     const eachFieldHandling = fieldIngestStatements.join('\n');
     const ingestStatements = [
         getRequestedFieldsStatement(importContext),
@@ -146,69 +152,19 @@ function iterateThroughResponseKeys(importContext, individualFieldIngestBlock) {
             }
             const ${constants_2.FIELD_KEY_IDENTIFIER} = ${getFieldKeyImport}(${constants_2.REQUESTED_FIELD_IDENTIFIER}, state.variables);
 
-            switch( ${constants_2.REQUESTED_FIELD_IDENTIFIER}.name.value) {
+            switch(${constants_2.REQUESTED_FIELD_IDENTIFIER}.name.value) {
                 ${individualFieldIngestBlock}
             }
         }
     `;
 }
-function generateRamlIngestDelegation(graphqlDsl, graphqlTypeName, importContext, def, modelInfo, graphqlStateInterface) {
-    // get the target RAML type ingest function
-    const { typeNameToExtensions } = graphqlDsl;
-    const { importRamlArtifact } = importContext;
-    const ramlTypeName = (0, utils_2.getRamlTypeName)(typeNameToExtensions, graphqlTypeName);
-    if (ramlTypeName === undefined) {
-        return '';
-    }
-    const ramlTypeId = (0, utils_2.getRamlTypeIdByName)(ramlTypeName, modelInfo);
-    if (ramlTypeId === undefined) {
-        return '';
-    }
-    const ramlIngest = importRamlArtifact(ramlTypeId, constants_2.TYPE_INGEST_IDENTIFIER);
-    // get RAML mapping
-    const graphqlFields = (0, types_1.getObjectFields)(def);
-    const ramlIngestStatements = graphqlFields
-        .filter((graphqlField) => graphqlField.type !== undefined)
-        .map((graphqlField) => {
-        const graphqlFieldName = graphqlField.name.value;
-        const ramlFieldName = (0, utils_2.getRamlFieldName)(typeNameToExtensions, graphqlTypeName, graphqlFieldName);
-        if (ramlFieldName === undefined) {
-            return '';
-        }
-        return (0, deindent_1.default) `
-                if (responseKey === "${graphqlFieldName}") {
-                    ramlSink["${ramlFieldName}"] = data["${graphqlFieldName}"];
-                }
-            `;
-    });
-    if (ramlIngestStatements.length === 0) {
-        return '';
-    }
-    return (0, deindent_1.default) `
-        export function convertGraphQLToRaml (state: ${graphqlStateInterface}<${interface_1.PARTIAL_INTERFACE_IDENTIFIER}>) {
-            const { path, data, ${constants_1.LUVIO_IDENTIFIER}, ${constants_1.LUVIO_STORE_IDENTIFIER}, ${constants_2.TIMESTAMP_IDENTIFIER} } = state;
-            const ramlSink = {};
-            const responseKeys = Object.keys(data);
-            for (const responseKey of responseKeys) {
-                ${ramlIngestStatements.join('\n')}
-            }
-
-            // delegate type ingest to RAML ingest if the type is in RAML mapping
-            if (Object.keys(ramlSink).length === 0) {
-                return undefined;
-            }
-            const ramlTypeRef = ${ramlIngest}(ramlSink, path, ${constants_1.LUVIO_IDENTIFIER}, ${constants_1.LUVIO_STORE_IDENTIFIER}, ${constants_2.TIMESTAMP_IDENTIFIER});
-            return ramlTypeRef;
-        }
-    `;
-}
 function generateIngest(graphqlDsl, graphqlTypeName, def, importContext, _metadata, modelInfo) {
     var _a;
     const { schema, typeNameToExtensions } = graphqlDsl;
-    const { importGraphQLArtifact, importAdapterUtil } = importContext;
+    const { importGraphQLArtifact, importAdapterUtil, importRamlArtifact } = importContext;
     const normalizableTypeMap = (0, utils_1.getNormalizableTypeMap)(schema);
     const createLink = importGraphQLArtifact('types', constants_2.TYPE_UTIL_IDENTIFIER, constants_2.CREATE_LINK_IDENTIFIER);
-    const graphqlStateInterface = importGraphQLArtifact('types', constants_2.TYPE_UTIL_IDENTIFIER, constants_2.GRAPHQL_STATE_INTERFACE_IDENTIFIER);
+    const graphqlStateInterface = importGraphQLArtifact('types', constants_2.TYPE_UTIL_IDENTIFIER, constants_2.GRAPHQL_INGEST_STATE_INTERFACE_IDENTIFIER);
     const keyPrefix = importAdapterUtil('keyPrefix');
     const ttl = (0, utils_2.isTypeExtensionDefined)(typeNameToExtensions, graphqlTypeName, 'ttl')
         ? 'TTL'
@@ -216,36 +172,46 @@ function generateIngest(graphqlDsl, graphqlTypeName, def, importContext, _metada
     const astNodeParamType = ((_a = schema.getQueryType()) === null || _a === void 0 ? void 0 : _a.name) === graphqlTypeName
         ? constants_1.LUVIO_GRAPHQL_OPERATION_DEFINITION_NODE_IMPORT
         : constants_1.LUVIO_GRAPHQL_FIELD_NODE_IMPORT;
-    const converToRaml = generateRamlIngestDelegation(graphqlDsl, graphqlTypeName, importContext, def, modelInfo, graphqlStateInterface);
+    const converToRaml = (0, convert_1.generateRamlConversion)(graphqlDsl, graphqlTypeName, importContext, def, modelInfo, graphqlStateInterface, normalizableTypeMap);
+    let ramlIngest = undefined;
+    const ramlTypeName = (0, utils_2.getRamlTypeName)(typeNameToExtensions, graphqlTypeName);
+    if (ramlTypeName !== undefined) {
+        const ramlTypeId = (0, utils_2.getRamlTypeIdByName)(ramlTypeName, modelInfo);
+        if (ramlTypeId !== undefined) {
+            ramlIngest = importRamlArtifact(ramlTypeId, constants_2.TYPE_INGEST_IDENTIFIER);
+        }
+    }
     return (0, deindent_1.default) `
 
         ${converToRaml}
 
         export function ingest(astNode: ${astNodeParamType}, state: ${graphqlStateInterface}<${interface_1.PARTIAL_INTERFACE_IDENTIFIER}>) {
-            const { path, ${constants_1.LUVIO_IDENTIFIER}, ${constants_1.LUVIO_STORE_IDENTIFIER}, ${constants_2.TIMESTAMP_IDENTIFIER} } = state;
-            const data = state.data;
-            const key = ${constants_2.KEY_BUILDER_IDENTIFIER}(path, data);
-            const dataSink = <PartialInterface>({});
+            const { path, data, ${constants_1.LUVIO_IDENTIFIER}, ${constants_1.LUVIO_STORE_IDENTIFIER}, ${constants_2.TIMESTAMP_IDENTIFIER} } = state;
+            const key = ${constants_2.KEY_BUILDER_IDENTIFIER}(${constants_1.LUVIO_IDENTIFIER}, path, data);
+            const ${constants_2.SINK_IDENTIFIER}: Record<string,any> = {};
             
             // normalize fields
             ${generateObjectTypeIngest(graphqlDsl, graphqlTypeName, importContext, def, normalizableTypeMap)}
 
             // merge existing cache data and new request response data
-            let mergedData;
+            let mergedData: Record<string,any>;
             const existingData = ${constants_1.LUVIO_STORE_IDENTIFIER}.readEntry<${interface_1.PARTIAL_INTERFACE_IDENTIFIER}>(key);
-            if (existingData !== undefined && existingData.__type !== "error") {
-                mergedData = mergeData(existingData as PartialInterface, dataSink);
+            if (existingData !== undefined && existingData !== null && existingData.__type !== "error") {
+                mergedData = mergeData(existingData as ${interface_1.PARTIAL_INTERFACE_IDENTIFIER}, ${constants_2.SINK_IDENTIFIER} as ${interface_1.PARTIAL_INTERFACE_IDENTIFIER});
             } 
             else {
-                mergedData = {data: dataSink};
+                mergedData = {data: ${constants_2.SINK_IDENTIFIER}};
             }
 
             ${converToRaml === ''
         ? ''
         : (0, deindent_1.default) `
-            // partially ingest with RAML
-            const ramlTypeRef = convertGraphQLToRaml(state);
-            if (ramlTypeRef !== undefined) {
+            // delegate type ingest to RAML ingest if the type is in RAML mapping
+            const ramlSink = convertGraphQLToRaml(astNode, state);
+            if (ramlSink !== undefined) {
+
+                // partially ingest with RAML
+                const ramlTypeRef = ${ramlIngest}(ramlSink, path, ${constants_1.LUVIO_IDENTIFIER}, ${constants_1.LUVIO_STORE_IDENTIFIER}, ${constants_2.TIMESTAMP_IDENTIFIER});
                 mergedData["__link"] = ramlTypeRef;
             }`}