@jahia/cypress 3.17.6 → 3.17.8

package/dist/support/provisioning/index.d.ts

@@ -1,3 +1,4 @@
 export * from './executeGroovy';
 export * from './runProvisioningScript';
 export * from './installBundle';
+export * from './uninstallBundle';

package/dist/support/provisioning/index.js

@@ -13,3 +13,4 @@ exports.__esModule = true;
 __exportStar(require("./executeGroovy"), exports);
 __exportStar(require("./runProvisioningScript"), exports);
 __exportStar(require("./installBundle"), exports);
+__exportStar(require("./uninstallBundle"), exports);

package/dist/support/provisioning/uninstallBundle.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="cypress" />
+declare global {
+    namespace Cypress {
+        interface Chainable<Subject> {
+            uninstallBundle(bundleSymbolicName: string): Chainable<Cypress.Response<any>>;
+        }
+    }
+}
+export declare const uninstallBundle: (bundleSymbolicName: string) => void;

package/dist/support/provisioning/uninstallBundle.js

@@ -0,0 +1,12 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+exports.__esModule = true;
+exports.uninstallBundle = void 0;
+/// <reference types="cypress" />
+var uninstallBundle = function (bundleSymbolicName) {
+    cy.runProvisioningScript({
+        fileContent: '- uninstallBundle: "' + bundleSymbolicName + '"\n',
+        type: 'application/yaml'
+    });
+};
+exports.uninstallBundle = uninstallBundle;

package/dist/utils/GraphQLHelper.d.ts

@@ -0,0 +1 @@
+export declare const getDescriptions: (rootNode: string) => Cypress.Chainable;

package/dist/utils/GraphQLHelper.js

@@ -0,0 +1,142 @@
+"use strict";
+/* eslint max-depth: ["error", 5] */
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+exports.__esModule = true;
+exports.getDescriptions = void 0;
+// This returns a flat list of all children fields and args for a given GraphQL node
+// This list can then be used in Cypress tests to look for missing descriptions
+var getDescriptions = function (rootNode) {
+    cy.log('Starting analysis from GraphQL node: ' + rootNode);
+    return execIntrospection(rootNode, [], []).then(function (descriptions) {
+        return descriptions;
+    });
+};
+exports.getDescriptions = getDescriptions;
+var execIntrospection = function (typeName, descriptions, nodePath) {
+    return cy.apollo({
+        variables: {
+            typeName: typeName
+        },
+        queryFile: 'graphql/introspection.graphql'
+    }).then(function (response) {
+        var _a;
+        var responseDataType = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.__type;
+        if (responseDataType === null || responseDataType === undefined || responseDataType.kind === 'UNION') {
+            return;
+        }
+        if (responseDataType) {
+            // This array will be populated with types identified in the introspection query
+            // These will then be further introspected to get their children fields and args
+            var fetchSubTypes_1 = [];
+            descriptions.push({
+                name: responseDataType.name,
+                description: responseDataType.description,
+                schemaType: '__Type',
+                schemaNode: responseDataType,
+                nodePath: nodePath
+            });
+            // The following exploration of the object follows precisely the Graphql Introspection
+            // spec available at https://github.com/graphql/graphql-spec/blob/main/spec/Section%204%20--%20Introspection.md
+            if (responseDataType.fields) {
+                for (var _i = 0, _b = responseDataType.fields; _i < _b.length; _i++) {
+                    var graphqlField = _b[_i];
+                    var fieldPath = __spreadArray(__spreadArray([], nodePath), [responseDataType.name, graphqlField.name]);
+                    descriptions.push({
+                        name: graphqlField.name,
+                        description: graphqlField.description,
+                        schemaType: '__Field',
+                        schemaNode: graphqlField,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes_1.push({ typeName: graphqlField.type.name, atPath: fieldPath });
+                    if (graphqlField.args) {
+                        for (var _c = 0, _d = graphqlField.args; _c < _d.length; _c++) {
+                            var graphQLInputValue = _d[_c];
+                            var inputValuePath = __spreadArray(__spreadArray([], fieldPath), [graphQLInputValue.name]);
+                            descriptions.push({
+                                name: graphQLInputValue.name,
+                                description: graphQLInputValue.description,
+                                schemaType: '__InputValue',
+                                schemaNode: graphQLInputValue,
+                                nodePath: inputValuePath
+                            });
+                            fetchSubTypes_1.push({ typeName: graphQLInputValue.type.name, atPath: inputValuePath });
+                        }
+                    }
+                }
+            }
+            if (responseDataType.interfaces) {
+                for (var _e = 0, _f = responseDataType.interfaces; _e < _f.length; _e++) {
+                    var graphQLInterfaceType = _f[_e];
+                    var fieldPath = __spreadArray(__spreadArray([], nodePath), [responseDataType.name, graphQLInterfaceType.name]);
+                    descriptions.push({
+                        name: graphQLInterfaceType.name,
+                        description: graphQLInterfaceType.description,
+                        schemaType: '__Type',
+                        schemaNode: graphQLInterfaceType,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes_1.push({ typeName: graphQLInterfaceType.name, atPath: fieldPath });
+                }
+            }
+            if (responseDataType.possibleTypes) {
+                for (var _g = 0, _h = responseDataType.possibleTypes; _g < _h.length; _g++) {
+                    var graphQLType = _h[_g];
+                    var fieldPath = __spreadArray(__spreadArray([], nodePath), [responseDataType.name, graphQLType.name]);
+                    descriptions.push({
+                        name: graphQLType.name,
+                        description: graphQLType.description,
+                        schemaType: '__Type',
+                        schemaNode: graphQLType,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes_1.push({ typeName: graphQLType.name, atPath: fieldPath });
+                }
+            }
+            if (responseDataType.enumValues) {
+                for (var _j = 0, _k = responseDataType.enumValues; _j < _k.length; _j++) {
+                    var graphQLEnumValue = _k[_j];
+                    var enumPath = __spreadArray(__spreadArray([], nodePath), [responseDataType.name, graphQLEnumValue.name]);
+                    descriptions.push({
+                        name: graphQLEnumValue.name,
+                        description: graphQLEnumValue.description,
+                        schemaType: '__EnumValue',
+                        schemaNode: graphQLEnumValue,
+                        nodePath: enumPath
+                    });
+                }
+            }
+            if (responseDataType.inputFields) {
+                for (var _l = 0, _m = responseDataType.inputFields; _l < _m.length; _l++) {
+                    var graphQLInputValue = _m[_l];
+                    var inputValuePath = __spreadArray(__spreadArray([], nodePath), [responseDataType.name, graphQLInputValue.name]);
+                    descriptions.push({
+                        name: graphQLInputValue.name,
+                        description: graphQLInputValue.description,
+                        schemaType: '__InputValue',
+                        schemaNode: graphQLInputValue,
+                        nodePath: inputValuePath
+                    });
+                    fetchSubTypes_1.push({ typeName: graphQLInputValue.type.name, atPath: inputValuePath });
+                }
+            }
+            if (responseDataType.ofType) {
+                fetchSubTypes_1.push({ typeName: responseDataType.ofType.name, atPath: nodePath });
+            }
+            var uniqueSubTypes = fetchSubTypes_1
+                // Filter out duplicate types to ensure we don't introspect the same type multiple times
+                .filter(function (obj, index) { return fetchSubTypes_1.findIndex(function (item) { return item.typeName === obj.typeName; }) === index; })
+                // Filter out types that have a name of null (e.g. List of non-null types)
+                .filter(function (subtype) { return subtype.typeName !== null; })
+                // Remove types that might have already been introspected
+                .filter(function (subtype) { return descriptions.find(function (d) { return d.schemaType === '__Type' && d.name === subtype.typeName; }) === undefined; });
+            return Cypress.Promise.each(uniqueSubTypes, function (subType) {
+                return execIntrospection(subType.typeName, descriptions, __spreadArray(__spreadArray([], subType.atPath), [subType.typeName]));
+            }).then(function () { return descriptions; }); // Return descriptions after all recursive calls have completed
+        }
+    });
+};

package/dist/utils/index.d.ts

@@ -5,3 +5,4 @@ export * from './UsersHelper';
 export * from './VanityUrlHelper';
 export * from './ClusterHelper';
 export * from './JahiaPlatformHelper';
+export * from './GraphQLHelper';

package/dist/utils/index.js

@@ -17,3 +17,4 @@ __exportStar(require("./UsersHelper"), exports);
 __exportStar(require("./VanityUrlHelper"), exports);
 __exportStar(require("./ClusterHelper"), exports);
 __exportStar(require("./JahiaPlatformHelper"), exports);
+__exportStar(require("./GraphQLHelper"), exports);

package/fixtures/graphql/introspection.graphql

@@ -0,0 +1,53 @@
+query IntrospectionQuery($typeName: String!) {
+    __type(name: $typeName) {
+        kind
+        name
+        description
+        fields(includeDeprecated: true) {
+            name
+            description
+            deprecationReason
+            isDeprecated
+            args {
+                name
+                description
+                type {
+                    kind
+                    name
+                }
+            }
+            type {
+                kind
+                name
+                description
+            }
+        }
+        interfaces {
+            name
+            description
+        }
+        possibleTypes {
+            name
+            description
+        }
+        enumValues(includeDeprecated: true) {
+            name
+            description
+            deprecationReason
+            isDeprecated
+        }
+        inputFields {
+            name
+            description
+            type {
+                kind
+                name
+                description
+            }
+        }
+        ofType {
+            name
+            description
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jahia/cypress",
-  "version": "3.17.6",
+  "version": "3.17.8",
   "scripts": {
     "build": "tsc",
     "lint": "eslint src -c .eslintrc.json --ext .ts"

package/src/support/provisioning/index.ts

@@ -1,3 +1,4 @@
 export * from './executeGroovy';
 export * from './runProvisioningScript';
 export * from './installBundle';
+export * from './uninstallBundle';

package/src/support/provisioning/uninstallBundle.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-namespace */
+
+// Load type definitions that come with Cypress module
+/// <reference types="cypress" />
+
+declare global {
+    namespace Cypress {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        interface Chainable<Subject> {
+            uninstallBundle(bundleSymbolicName: string): Chainable<Cypress.Response<any>>
+        }
+    }
+}
+
+export const uninstallBundle = function (bundleSymbolicName: string): void {
+    cy.runProvisioningScript({
+        fileContent: '- uninstallBundle: "' + bundleSymbolicName + '"\n',
+        type: 'application/yaml'
+    });
+};

package/src/utils/GraphQLHelper.ts

@@ -0,0 +1,152 @@
+/* eslint max-depth: ["error", 5] */
+
+interface GraphQLField {
+    name: string;
+}
+
+interface GraphQLDescription {
+    name: string; // Name of the element in the schema
+    description: string; // Description of the element in the schema
+    schemaType: string; // Type of the element in the schema according to the GraphQL spec
+    schemaNode: GraphQLField; // The actual node fetched from the schema
+    nodePath: string[] // The path to the node in the schema
+}
+
+// This returns a flat list of all children fields and args for a given GraphQL node
+// This list can then be used in Cypress tests to look for missing descriptions
+export const getDescriptions = (rootNode: string): Cypress.Chainable => {
+    cy.log('Starting analysis from GraphQL node: ' + rootNode);
+    return execIntrospection(rootNode, [], []).then(descriptions => {
+        return descriptions;
+    });
+};
+
+const execIntrospection = (typeName: string, descriptions: GraphQLDescription[], nodePath): Cypress.Chainable => {
+    return cy.apollo({
+        variables: {
+            typeName: typeName
+        },
+        queryFile: 'graphql/introspection.graphql'
+    }).then(response => {
+        const responseDataType = response?.data?.__type;
+        if (responseDataType === null || responseDataType === undefined || responseDataType.kind === 'UNION') {
+            return;
+        }
+
+        if (responseDataType) {
+            // This array will be populated with types identified in the introspection query
+            // These will then be further introspected to get their children fields and args
+            const fetchSubTypes: {typeName: string, atPath: string[]}[] = [];
+
+            descriptions.push({
+                name: responseDataType.name,
+                description: responseDataType.description,
+                schemaType: '__Type',
+                schemaNode: responseDataType,
+                nodePath
+            });
+
+            // The following exploration of the object follows precisely the Graphql Introspection
+            // spec available at https://github.com/graphql/graphql-spec/blob/main/spec/Section%204%20--%20Introspection.md
+            if (responseDataType.fields) {
+                for (const graphqlField of responseDataType.fields) {
+                    const fieldPath = [...nodePath, responseDataType.name, graphqlField.name];
+                    descriptions.push({
+                        name: graphqlField.name,
+                        description: graphqlField.description,
+                        schemaType: '__Field',
+                        schemaNode: graphqlField,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes.push({typeName: graphqlField.type.name, atPath: fieldPath});
+
+                    if (graphqlField.args) {
+                        for (const graphQLInputValue of graphqlField.args) {
+                            const inputValuePath = [...fieldPath, graphQLInputValue.name];
+                            descriptions.push({
+                                name: graphQLInputValue.name,
+                                description: graphQLInputValue.description,
+                                schemaType: '__InputValue',
+                                schemaNode: graphQLInputValue,
+                                nodePath: inputValuePath
+                            });
+                            fetchSubTypes.push({typeName: graphQLInputValue.type.name, atPath: inputValuePath});
+                        }
+                    }
+                }
+            }
+
+            if (responseDataType.interfaces) {
+                for (const graphQLInterfaceType of responseDataType.interfaces) {
+                    const fieldPath = [...nodePath, responseDataType.name, graphQLInterfaceType.name];
+                    descriptions.push({
+                        name: graphQLInterfaceType.name,
+                        description: graphQLInterfaceType.description,
+                        schemaType: '__Type',
+                        schemaNode: graphQLInterfaceType,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes.push({typeName: graphQLInterfaceType.name, atPath: fieldPath});
+                }
+            }
+
+            if (responseDataType.possibleTypes) {
+                for (const graphQLType of responseDataType.possibleTypes) {
+                    const fieldPath = [...nodePath, responseDataType.name, graphQLType.name];
+                    descriptions.push({
+                        name: graphQLType.name,
+                        description: graphQLType.description,
+                        schemaType: '__Type',
+                        schemaNode: graphQLType,
+                        nodePath: fieldPath
+                    });
+                    fetchSubTypes.push({typeName: graphQLType.name, atPath: fieldPath});
+                }
+            }
+
+            if (responseDataType.enumValues) {
+                for (const graphQLEnumValue of responseDataType.enumValues) {
+                    const enumPath = [...nodePath, responseDataType.name, graphQLEnumValue.name];
+                    descriptions.push({
+                        name: graphQLEnumValue.name,
+                        description: graphQLEnumValue.description,
+                        schemaType: '__EnumValue',
+                        schemaNode: graphQLEnumValue,
+                        nodePath: enumPath
+                    });
+                }
+            }
+
+            if (responseDataType.inputFields) {
+                for (const graphQLInputValue of responseDataType.inputFields) {
+                    const inputValuePath = [...nodePath, responseDataType.name, graphQLInputValue.name];
+                    descriptions.push({
+                        name: graphQLInputValue.name,
+                        description: graphQLInputValue.description,
+                        schemaType: '__InputValue',
+                        schemaNode: graphQLInputValue,
+                        nodePath: inputValuePath
+                    });
+                    fetchSubTypes.push({typeName: graphQLInputValue.type.name, atPath: inputValuePath});
+                }
+            }
+
+            if (responseDataType.ofType) {
+                fetchSubTypes.push({typeName: responseDataType.ofType.name, atPath: nodePath});
+            }
+
+            const uniqueSubTypes = fetchSubTypes
+                // Filter out duplicate types to ensure we don't introspect the same type multiple times
+                .filter((obj, index) => fetchSubTypes.findIndex(item => item.typeName === obj.typeName) === index)
+                // Filter out types that have a name of null (e.g. List of non-null types)
+                .filter(subtype => subtype.typeName !== null)
+                // Remove types that might have already been introspected
+                .filter(subtype => descriptions.find(d => d.schemaType === '__Type' && d.name === subtype.typeName) === undefined);
+
+            return Cypress.Promise.each(uniqueSubTypes, subType => {
+                return execIntrospection(subType.typeName, descriptions, [...subType.atPath, subType.typeName]);
+            }).then(() => descriptions); // Return descriptions after all recursive calls have completed
+        }
+    });
+};
+

package/src/utils/index.ts

@@ -5,3 +5,4 @@ export * from './UsersHelper';
 export * from './VanityUrlHelper';
 export * from './ClusterHelper';
 export * from './JahiaPlatformHelper';
+export * from './GraphQLHelper';