@graphql-inspector/action 0.0.0-canary.35db993 → 0.0.0-canary.4c9888f

package/index.js

@@ -0,0 +1,423 @@
+'use strict';
+
+const core = require('@actions/core');
+const tslib = require('tslib');
+const github = require('@graphql-inspector/github');
+const fs = require('fs');
+const path = require('path');
+const child_process = require('child_process');
+const github$1 = require('@actions/github');
+
+const MAX_ARRAY_LENGTH = 10;
+const MAX_RECURSIVE_DEPTH = 2;
+/**
+ * Used to print values in error messages.
+ */
+
+function inspect(value) {
+  return formatValue(value, []);
+}
+
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case 'string':
+      return JSON.stringify(value);
+
+    case 'function':
+      return value.name ? `[function ${value.name}]` : '[function]';
+
+    case 'object':
+      return formatObjectValue(value, seenValues);
+
+    default:
+      return String(value);
+  }
+}
+
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return 'null';
+  }
+
+  if (previouslySeenValues.includes(value)) {
+    return '[Circular]';
+  }
+
+  const seenValues = [...previouslySeenValues, value];
+
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON(); // check for infinite recursion
+
+    if (jsonValue !== value) {
+      return typeof jsonValue === 'string'
+        ? jsonValue
+        : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+
+  return formatObject(value, seenValues);
+}
+
+function isJSONable(value) {
+  return typeof value.toJSON === 'function';
+}
+
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+
+  if (entries.length === 0) {
+    return '{}';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[' + getObjectTag(object) + ']';
+  }
+
+  const properties = entries.map(
+    ([key, value]) => key + ': ' + formatValue(value, seenValues),
+  );
+  return '{ ' + properties.join(', ') + ' }';
+}
+
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return '[]';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[Array]';
+  }
+
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+
+  for (let i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+
+  if (remaining === 1) {
+    items.push('... 1 more item');
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+
+  return '[' + items.join(', ') + ']';
+}
+
+function getObjectTag(object) {
+  const tag = Object.prototype.toString
+    .call(object)
+    .replace(/^\[object /, '')
+    .replace(/]$/, '');
+
+  if (tag === 'Object' && typeof object.constructor === 'function') {
+    const name = object.constructor.name;
+
+    if (typeof name === 'string' && name !== '') {
+      return name;
+    }
+  }
+
+  return tag;
+}
+
+function devAssert(condition, message) {
+  const booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
+
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+
+/**
+ * A representation of source input to GraphQL. The `name` and `locationOffset` parameters are
+ * optional, but they are useful for clients who store GraphQL documents in source files.
+ * For example, if the GraphQL input starts at line 40 in a file named `Foo.graphql`, it might
+ * be useful for `name` to be `"Foo.graphql"` and location to be `{ line: 40, column: 1 }`.
+ * The `line` and `column` properties in `locationOffset` are 1-indexed.
+ */
+class Source {
+  constructor(
+    body,
+    name = 'GraphQL request',
+    locationOffset = {
+      line: 1,
+      column: 1,
+    },
+  ) {
+    typeof body === 'string' ||
+      devAssert(false, `Body must be a string. Received: ${inspect(body)}.`);
+    this.body = body;
+    this.name = name;
+    this.locationOffset = locationOffset;
+    this.locationOffset.line > 0 ||
+      devAssert(
+        false,
+        'line in locationOffset is 1-indexed and must be positive.',
+      );
+    this.locationOffset.column > 0 ||
+      devAssert(
+        false,
+        'column in locationOffset is 1-indexed and must be positive.',
+      );
+  }
+
+  get [Symbol.toStringTag]() {
+    return 'Source';
+  }
+}
+
+function batch(items, limit) {
+    const batches = [];
+    const batchesNum = Math.ceil(items.length / limit);
+    // We still want to update check-run and send empty annotations
+    if (batchesNum === 0) {
+        return [[]];
+    }
+    for (let i = 0; i < batchesNum; i++) {
+        const start = i * limit;
+        const end = start + limit;
+        batches.push(items.slice(start, end));
+    }
+    return batches;
+}
+
+const CHECK_NAME = 'GraphQL Inspector';
+function getCurrentCommitSha() {
+    const sha = child_process.execSync(`git rev-parse HEAD`).toString().trim();
+    try {
+        const msg = child_process.execSync(`git show ${sha} -s --format=%s`).toString().trim();
+        const PR_MSG = /Merge (\w+) into \w+/i;
+        if (PR_MSG.test(msg)) {
+            const result = PR_MSG.exec(msg);
+            if (result) {
+                return result[1];
+            }
+        }
+    }
+    catch (e) {
+        //
+    }
+    return sha;
+}
+function run() {
+    var _a, _b, _c;
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        core.info(`GraphQL Inspector started`);
+        // env
+        let ref = process.env.GITHUB_SHA;
+        const commitSha = getCurrentCommitSha();
+        core.info(`Ref: ${ref}`);
+        core.info(`Commit SHA: ${commitSha}`);
+        const token = core.getInput('github-token', { required: true });
+        const checkName = core.getInput('name') || CHECK_NAME;
+        let workspace = process.env.GITHUB_WORKSPACE;
+        if (!workspace) {
+            return core.setFailed('Failed to resolve workspace directory. GITHUB_WORKSPACE is missing');
+        }
+        const useMerge = castToBoolean(core.getInput('experimental_merge'), true);
+        const useAnnotations = castToBoolean(core.getInput('annotations'));
+        const failOnBreaking = castToBoolean(core.getInput('fail-on-breaking'));
+        const endpoint = core.getInput('endpoint');
+        const approveLabel = core.getInput('approve-label') || 'approved-breaking-change';
+        const octokit = github$1.getOctokit(token);
+        // repo
+        const { owner, repo } = github$1.context.repo;
+        core.info(`Creating a check named "${checkName}"`);
+        const check = yield octokit.checks.create({
+            owner,
+            repo,
+            name: checkName,
+            head_sha: commitSha,
+            status: 'in_progress',
+        });
+        const checkId = check.data.id;
+        core.info(`Check ID: ${checkId}`);
+        const schemaPointer = core.getInput('schema', { required: true });
+        const loadFile = fileLoader({
+            octokit,
+            owner,
+            repo,
+        });
+        if (!schemaPointer) {
+            core.error('No `schema` variable');
+            return core.setFailed('Failed to find `schema` variable');
+        }
+        let [schemaRef, schemaPath] = schemaPointer.split(':');
+        if (useMerge && github$1.context.payload.pull_request) {
+            ref = `refs/pull/${github$1.context.payload.pull_request.number}/merge`;
+            workspace = undefined;
+            core.info(`EXPERIMENTAL - Using Pull Request ${ref}`);
+            const baseRef = (_b = (_a = github$1.context.payload.pull_request) === null || _a === void 0 ? void 0 : _a.base) === null || _b === void 0 ? void 0 : _b.ref;
+            if (baseRef) {
+                schemaRef = baseRef;
+                core.info(`EXPERIMENTAL - Using ${baseRef} as base schema ref`);
+            }
+        }
+        if (endpoint) {
+            schemaPath = schemaPointer;
+        }
+        const isNewSchemaUrl = endpoint && schemaPath.startsWith('http');
+        const [oldFile, newFile] = yield Promise.all([
+            endpoint
+                ? github.printSchemaFromEndpoint(endpoint)
+                : loadFile({
+                    ref: schemaRef,
+                    path: schemaPath,
+                }),
+            isNewSchemaUrl
+                ? github.printSchemaFromEndpoint(schemaPath)
+                : loadFile({
+                    path: schemaPath,
+                    ref,
+                    workspace,
+                }),
+        ]);
+        core.info('Got both sources');
+        const sources = {
+            old: new Source(oldFile, endpoint || `${schemaRef}:${schemaPath}`),
+            new: new Source(newFile, schemaPath),
+        };
+        const schemas = {
+            old: github.produceSchema(sources.old),
+            new: github.produceSchema(sources.new),
+        };
+        core.info(`Built both schemas`);
+        core.info(`Start comparing schemas`);
+        const action = yield github.diff({
+            path: schemaPath,
+            schemas,
+            sources,
+        });
+        let conclusion = action.conclusion;
+        let annotations = action.annotations || [];
+        const changes = action.changes || [];
+        core.setOutput('changes', `${changes.length || 0}`);
+        core.info(`Changes: ${changes.length || 0}`);
+        const hasApprovedBreakingChangeLabel = github$1.context.payload.pull_request
+            ? (_c = github$1.context.payload.pull_request.labels) === null || _c === void 0 ? void 0 : _c.some((label) => label.name === approveLabel)
+            : false;
+        // Force Success when failOnBreaking is disabled
+        if ((failOnBreaking === false || hasApprovedBreakingChangeLabel) && conclusion === github.CheckConclusion.Failure) {
+            core.info('FailOnBreaking disabled. Forcing SUCCESS');
+            conclusion = github.CheckConclusion.Success;
+        }
+        if (useAnnotations === false || isNewSchemaUrl) {
+            core.info(`Anotations are disabled. Skipping annotations...`);
+            annotations = [];
+        }
+        const summary = github.createSummary(changes, 100, false);
+        const title = conclusion === github.CheckConclusion.Failure
+            ? 'Something is wrong with your schema'
+            : 'Everything looks good';
+        core.info(`Conclusion: ${conclusion}`);
+        try {
+            return yield updateCheckRun(octokit, checkId, {
+                conclusion,
+                output: { title, summary, annotations },
+            });
+        }
+        catch (e) {
+            // Error
+            core.error(e.message || e);
+            const title = 'Invalid config. Failed to add annotation';
+            yield updateCheckRun(octokit, checkId, {
+                conclusion: github.CheckConclusion.Failure,
+                output: { title, summary: title, annotations: [] },
+            });
+            return core.setFailed(title);
+        }
+    });
+}
+function fileLoader({ octokit, owner, repo, }) {
+    const query = /* GraphQL */ `
+    query GetFile($repo: String!, $owner: String!, $expression: String!) {
+      repository(name: $repo, owner: $owner) {
+        object(expression: $expression) {
+          ... on Blob {
+            text
+          }
+        }
+      }
+    }
+  `;
+    return function loadFile(file) {
+        var _a, _b;
+        return tslib.__awaiter(this, void 0, void 0, function* () {
+            if (file.workspace) {
+                return fs.readFileSync(path.resolve(file.workspace, file.path), {
+                    encoding: 'utf-8',
+                });
+            }
+            const result = yield octokit.graphql(query, {
+                repo,
+                owner,
+                expression: `${file.ref}:${file.path}`,
+            });
+            core.info(`Query ${file.ref}:${file.path} from ${owner}/${repo}`);
+            try {
+                if ((_b = (_a = result === null || result === void 0 ? void 0 : result.repository) === null || _a === void 0 ? void 0 : _a.object) === null || _b === void 0 ? void 0 : _b.text) {
+                    return result.repository.object.text;
+                }
+                throw new Error('result.repository.object.text is null');
+            }
+            catch (error) {
+                console.log(result);
+                console.error(error);
+                throw new Error(`Failed to load '${file.path}' (ref: ${file.ref})`);
+            }
+        });
+    };
+}
+function updateCheckRun(octokit, checkId, { conclusion, output }) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        core.info(`Updating check: ${checkId}`);
+        const { title, summary, annotations = [] } = output;
+        const batches = batch(annotations, 50);
+        core.info(`annotations to be sent: ${annotations.length}`);
+        yield octokit.checks.update(Object.assign(Object.assign({ check_run_id: checkId, completed_at: new Date().toISOString(), status: 'completed' }, github$1.context.repo), { conclusion, output: {
+                title, summary
+            } }));
+        try {
+            yield Promise.all(batches.map((chunk) => tslib.__awaiter(this, void 0, void 0, function* () {
+                yield octokit.checks.update(Object.assign(Object.assign({ check_run_id: checkId }, github$1.context.repo), { output: {
+                        title,
+                        summary,
+                        annotations: chunk,
+                    } }));
+                core.info(`annotations sent (${chunk.length})`);
+            })));
+        }
+        catch (error) {
+            core.error(`failed to send annotations: ${error}`);
+            throw error;
+        }
+        // Fail
+        if (conclusion === github.CheckConclusion.Failure) {
+            return core.setFailed(output.title);
+        }
+        // Success or Neutral
+    });
+}
+/**
+ * Treats non-falsy value as true
+ */
+function castToBoolean(value, defaultValue) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (value === 'true' || value === 'false') {
+        return value === 'true';
+    }
+    if (typeof defaultValue === 'boolean') {
+        return defaultValue;
+    }
+    return true;
+}
+
+run().catch((e) => {
+    core.setFailed(e.message || e);
+});