feat(resolve-check-config): graphql smoke test opt-out by default

.github/workflows/check-store.yaml

@@ -236,9 +236,14 @@ jobs:
           magento_path: ${{ inputs.path }}
 
       - uses: graycoreio/github-actions-magento2/smoke-test@main
+        if: contains(fromJSON(needs.compute_matrix.outputs.resolved)['smoke-test'].probes, 'page')
         with:
           kind: page
 
+      ## graphql is opt-in: editions without GraphQL modules (e.g. mage-os
+      ## minimal) have no /graphql endpoint. Enable it per store via
+      ## `.github/check-store.json` -> jobs.smoke-test.probes: ["page", "graphql"].
       - uses: graycoreio/github-actions-magento2/smoke-test@main
+        if: contains(fromJSON(needs.compute_matrix.outputs.resolved)['smoke-test'].probes, 'graphql')
         with:
           kind: graphql

docs/workflows/check-extension.md

@@ -24,7 +24,7 @@ Each check can be toggled on/off through an optional `.github/check-extension.js
 
 You can learn more about this file here in the [`resolve-check-config` action.](../../resolve-check-config/README.md): 
 
-Reference the published JSON Schema with `$schema` to get autocompletion and inline validation in editors that support it:
+Reference the published JSON Schema with `$schema` to get autocompletion and inline validation in editors that support it — see [`check-extension.schema.json`](../../resolve-check-config/check-extension.schema.json):
 
 ```json
 {

docs/workflows/check-store.md

@@ -32,7 +32,7 @@ Each check can be toggled on/off through an optional `.github/check-store.json`
 
 You can learn more about this file here in the [`resolve-check-config` action.](../../resolve-check-config/README.md): 
 
-Reference the published JSON Schema with `$schema` to get autocompletion and inline validation in editors that support it:
+Reference the published JSON Schema with `$schema` to get autocompletion and inline validation in editors that support it — see [`check-store.schema.json`](../../resolve-check-config/check-store.schema.json):
 
 ```json
 {

resolve-check-config/README.md

@@ -4,6 +4,13 @@ Reads `.github/check-<kind>.json` (or a path you specify), validates job names a
 
 A missing config file is fine — every known job is emitted with its default tier list.
 
+## Schemas
+
+Reference the published JSON Schema from your config's `$schema` key for autocompletion and inline validation in editors that support it:
+
+- [`check-store.schema.json`](./check-store.schema.json) — config for the [MageCheck Store](../docs/workflows/check-store.md) workflow
+- [`check-extension.schema.json`](./check-extension.schema.json) — config for the [MageCheck Extension](../docs/workflows/check-extension.md) workflow 
+
 ## Inputs
 
 | Input         | Description                                                                                                                                            | Required | Default                       |

resolve-check-config/check-store.schema.json

@@ -11,7 +11,7 @@
       "properties": {
         "unit-test": { "$ref": "#/$defs/jobConfig" },
         "coding-standard": { "$ref": "#/$defs/jobConfig" },
-        "smoke-test": { "$ref": "#/$defs/jobConfig" }
+        "smoke-test": { "$ref": "#/$defs/smokeJobConfig" }
       },
       "additionalProperties": false
     }
@@ -34,6 +34,29 @@
           "additionalProperties": true
         }
       ]
+    },
+    "smokeJobConfig": {
+      "description": "How the smoke-test job should be configured. Boolean form is shorthand for { enabled: <bool> }; object form adds a `probes` list on top of `enabled`.",
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "object",
+          "properties": {
+            "enabled": {
+              "type": "boolean",
+              "description": "Whether the job should run. Defaults to true when the key is present.",
+              "default": true
+            },
+            "probes": {
+              "type": "array",
+              "description": "Which smoke-test probes to run. Defaults to [\"page\"]. Add \"graphql\" to also probe the GraphQL endpoint — only for editions that ship GraphQL modules (the mage-os minimal edition does not, so /graphql 404s there).",
+              "items": { "enum": ["page", "graphql"] },
+              "default": ["page"]
+            }
+          },
+          "additionalProperties": true
+        }
+      ]
     }
   }
 }

resolve-check-config/src/kinds/store.spec.ts

@@ -31,6 +31,10 @@ describe('STORE_JOBS', () => {
     ]);
   });
 
+  it('defaults smoke-test to the page probe only (graphql is opt-in)', () => {
+    expect(STORE_JOBS['smoke-test'].probes).toEqual(['page']);
+  });
+
   it('exposes empty service defaults for unit-test and coding-standard', () => {
     expect(STORE_JOBS['unit-test'].services).toEqual([]);
     expect(STORE_JOBS['coding-standard'].services).toEqual([]);
@@ -79,6 +83,31 @@ describe('resolveStoreConfig', () => {
     expect(resolved['smoke-test'].enabled).toBe(false);
   });
 
+  it('emits the default page-only probe list for smoke-test', () => {
+    const resolved = resolveStoreConfig({}, MATRIX);
+    expect(resolved['smoke-test'].probes).toEqual(['page']);
+  });
+
+  it('honors a smoke-test probes override', () => {
+    const resolved = resolveStoreConfig(
+      { jobs: { 'smoke-test': { probes: ['page', 'graphql'] } } },
+      MATRIX,
+    );
+    expect(resolved['smoke-test'].probes).toEqual(['page', 'graphql']);
+  });
+
+  it('does not emit probes on jobs without a probe concept', () => {
+    const resolved = resolveStoreConfig({}, MATRIX);
+    expect(resolved['unit-test'].probes).toBeUndefined();
+    expect(resolved['coding-standard'].probes).toBeUndefined();
+  });
+
+  it('rejects probes on a job that does not support it', () => {
+    expect(() => resolveStoreConfig({ jobs: { 'unit-test': { probes: ['page'] } } }, MATRIX)).toThrowError(
+      /job "unit-test" does not support "probes"/
+    );
+  });
+
   it('throws on a typo in the job name', () => {
     expect(() => resolveStoreConfig({ jobs: { 'smkoe-test': false } }, MATRIX)).toThrowError(
       /unknown job "smkoe-test" for kind "store"/

resolve-check-config/src/kinds/store.ts

@@ -14,6 +14,7 @@ export const STORE_JOBS: Record<string, JobDefaults> = {
   'smoke-test': {
     services: [],
     requiredServices: ['db', 'search', 'queue', 'cache', 'web'],
+    probes: ['page'],
   },
 };
 

resolve-check-config/src/parse.spec.ts

@@ -3,6 +3,7 @@ import {
   filterMatrixForJob,
   mergeRequiredTiers,
   normalizeJobEntry,
+  normalizeProbes,
   parseMatrixInput,
   parseRawConfig,
   resolveJobs,
@@ -24,6 +25,7 @@ const MATRIX: Matrix = {
 
 const noDefaults: JobDefaults = { services: [] };
 const smokeDefaults: JobDefaults = { services: ['search', 'queue', 'cache', 'web'] };
+const probeDefaults: JobDefaults = { services: [], probes: ['page'] };
 
 describe('normalizeJobEntry', () => {
   it('defaults enabled=true and uses the default tiers when entry is undefined', () => {
@@ -96,6 +98,66 @@ describe('normalizeJobEntry', () => {
       /services contains unknown tier "llm"/
     );
   });
+
+  it('carries the default probes when the entry omits them', () => {
+    expect(normalizeJobEntry('smoke-test', { services: [] }, probeDefaults)).toEqual({
+      enabled: true,
+      tiers: [],
+      probes: ['page'],
+    });
+  });
+
+  it('carries the default probes for the boolean shorthand', () => {
+    expect(normalizeJobEntry('smoke-test', true, probeDefaults)).toEqual({
+      enabled: true,
+      tiers: [],
+      probes: ['page'],
+    });
+  });
+
+  it('overrides the default probes when probes is set', () => {
+    expect(normalizeJobEntry('smoke-test', { probes: ['page', 'graphql'] }, probeDefaults)).toEqual({
+      enabled: true,
+      tiers: [],
+      probes: ['page', 'graphql'],
+    });
+  });
+
+  it('omits probes for a job that declares no probe defaults', () => {
+    expect(normalizeJobEntry('unit-test', { services: [] }, noDefaults).probes).toBeUndefined();
+  });
+});
+
+describe('normalizeProbes', () => {
+  it('returns the defaults when probes is omitted', () => {
+    expect(normalizeProbes('smoke-test', undefined, ['page'])).toEqual(['page']);
+  });
+
+  it('returns undefined for a job with no probe defaults when omitted', () => {
+    expect(normalizeProbes('unit-test', undefined, undefined)).toBeUndefined();
+  });
+
+  it('throws when probes is set on a job that does not support it', () => {
+    expect(() => normalizeProbes('unit-test', ['page'], undefined)).toThrowError(
+      /job "unit-test" does not support "probes"/
+    );
+  });
+
+  it('throws when probes is not an array', () => {
+    expect(() => normalizeProbes('smoke-test', 'page', ['page'])).toThrowError(
+      /probes must be an array of probe names/
+    );
+  });
+
+  it('throws when probes contains an unknown probe', () => {
+    expect(() => normalizeProbes('smoke-test', ['rest'], ['page'])).toThrowError(
+      /probes contains unknown probe "rest"/
+    );
+  });
+
+  it('accepts an empty probes array', () => {
+    expect(normalizeProbes('smoke-test', [], ['page'])).toEqual([]);
+  });
 });
 
 describe('mergeRequiredTiers', () => {

resolve-check-config/src/parse.ts

@@ -1,34 +1,67 @@
 import { JobDefaults, Kind, Matrix, MatrixEntry, RawConfig, RawJobConfig, ResolvedConfig, ResolvedJobConfig, Services } from './types';
 import { isTier, servicesForTiers, Tier } from './tier-map';
+import { isProbe, Probe } from './probe';
 
 /**
- * Normalizes a single raw job entry to (enabled, tiers). Accepts
- * the boolean shorthand and the object form. Validates the shape
- * and the `services` tier list; throws on unexpected input. The
- * caller supplies the per-job default tiers, used when `services`
- * is omitted from the entry.
+ * Normalizes the `probes` value from a job entry. Returns the
+ * caller's list when present (validated), the job's default probe
+ * list when omitted, or `undefined` for jobs that have no probe
+ * concept. Throws if a job without probe defaults is given `probes`.
+ */
+export const normalizeProbes = (
+  jobName: string,
+  raw: unknown,
+  defaults: readonly Probe[] | undefined,
+): readonly Probe[] | undefined => {
+  if (raw === undefined) {
+    return defaults;
+  }
+  if (defaults === undefined) {
+    throw new Error(`check-config: job "${jobName}" does not support "probes"`);
+  }
+  if (!Array.isArray(raw)) {
+    throw new Error(`check-config: job "${jobName}".probes must be an array of probe names`);
+  }
+  const probes: Probe[] = [];
+  for (const value of raw) {
+    if (!isProbe(value)) {
+      throw new Error(`check-config: job "${jobName}".probes contains unknown probe "${String(value)}"`);
+    }
+    probes.push(value);
+  }
+  return probes;
+}
+
+/**
+ * Normalizes a single raw job entry to (enabled, tiers, probes).
+ * Accepts the boolean shorthand and the object form. Validates the
+ * shape, the `services` tier list, and the `probes` list; throws on
+ * unexpected input. The caller supplies the per-job defaults, used
+ * when `services`/`probes` are omitted from the entry. `probes` is
+ * `undefined` for jobs that declare no probe defaults.
  */
 export const normalizeJobEntry = (
   jobName: string,
   raw: RawJobConfig | undefined,
   defaults: JobDefaults,
-): { enabled: boolean; tiers: readonly Tier[] } => {
+): { enabled: boolean; tiers: readonly Tier[]; probes?: readonly Probe[] } => {
   if (raw === undefined) {
-    return { enabled: true, tiers: defaults.services };
+    return { enabled: true, tiers: defaults.services, probes: defaults.probes };
   }
   if (typeof raw === 'boolean') {
-    return { enabled: raw, tiers: defaults.services };
+    return { enabled: raw, tiers: defaults.services, probes: defaults.probes };
   }
   if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
     throw new Error(
       `check-config: job "${jobName}" must be a boolean or an object (got ${Array.isArray(raw) ? 'array' : typeof raw})`
     );
   }
-  const { enabled, services } = raw as { enabled?: unknown; services?: unknown };
+  const { enabled, services, probes } = raw as { enabled?: unknown; services?: unknown; probes?: unknown };
   const enabledValue = enabled === undefined ? true : Boolean(enabled);
+  const resolvedProbes = normalizeProbes(jobName, probes, defaults.probes);
 
   if (services === undefined) {
-    return { enabled: enabledValue, tiers: defaults.services };
+    return { enabled: enabledValue, tiers: defaults.services, probes: resolvedProbes };
   }
   if (!Array.isArray(services)) {
     throw new Error(`check-config: job "${jobName}".services must be an array of tier names`);
@@ -40,7 +73,7 @@ export const normalizeJobEntry = (
     }
     tiers.push(value);
   }
-  return { enabled: enabledValue, tiers };
+  return { enabled: enabledValue, tiers, probes: resolvedProbes };
 }
 
 /**
@@ -117,12 +150,16 @@ export const resolveJobs = (
   const resolved: ResolvedConfig = {};
   for (const [name, defaults] of Object.entries(jobs)) {
     const entry = (rawJobs as Record<string, RawJobConfig>)[name];
-    const { enabled, tiers } = normalizeJobEntry(name, entry, defaults);
+    const { enabled, tiers, probes } = normalizeJobEntry(name, entry, defaults);
     const finalTiers = mergeRequiredTiers(tiers, defaults.requiredServices);
-    resolved[name] = {
+    const resolvedEntry: ResolvedJobConfig = {
       enabled,
       matrix: filterMatrixForJob(matrix, finalTiers),
-    } as ResolvedJobConfig;
+    };
+    if (probes !== undefined) {
+      resolvedEntry.probes = [...probes];
+    }
+    resolved[name] = resolvedEntry;
   }
   return resolved;
 }

resolve-check-config/src/probe.ts

@@ -0,0 +1,13 @@
+/**
+ * A smoke-test probe the check-store workflow can run against a
+ * running store. `page` does a GET / and asserts a non-empty title;
+ * `graphql` POSTs a storeConfig query to /graphql. Probes are opt-in
+ * per job because not every edition exposes every surface (e.g. the
+ * mage-os minimal edition ships no GraphQL modules, so /graphql 404s).
+ */
+export const PROBES = ['page', 'graphql'] as const;
+
+export type Probe = (typeof PROBES)[number];
+
+export const isProbe = (value: unknown): value is Probe =>
+  typeof value === 'string' && (PROBES as readonly string[]).includes(value);

resolve-check-config/src/types.ts

@@ -1,4 +1,5 @@
 import { Tier } from './tier-map';
+import { Probe } from './probe';
 
 /**
  * Which reusable workflow a config belongs to. Selects the known-job
@@ -53,10 +54,15 @@ export interface Matrix {
  * regardless of caller overrides. Use it for tiers a job structurally
  * cannot run without (e.g. mysql for a running store smoke-test) and
  * which therefore should not appear in the user-facing schema enum.
+ *
+ * `probes` is the default smoke-test probe list used when the caller
+ * does not override it. Only jobs that declare it support the
+ * `probes` config key; omit it for jobs that have no probe concept.
  */
 export interface JobDefaults {
   services: readonly Tier[];
   requiredServices?: readonly Tier[];
+  probes?: readonly Probe[];
 }
 
 /**
@@ -67,6 +73,7 @@ export interface JobDefaults {
 export interface ResolvedJobConfig {
   enabled: boolean;
   matrix: Matrix;
+  probes?: Probe[];
   [key: string]: unknown;
 }
 
@@ -83,11 +90,12 @@ export interface ResolvedConfig {
  * Shape of a single per-job entry in the user's JSON config file.
  * - `true` / `false`: shorthand for `{ enabled: true|false }`
  * - object: explicit enabled flag plus an optional tier list under
- *   `services` (validated against the per-kind schema).
+ *   `services` and an optional probe list under `probes` (both
+ *   validated against the per-kind schema).
  */
 export type RawJobConfig =
   | boolean
-  | { enabled?: boolean; services?: string[]; [key: string]: unknown };
+  | { enabled?: boolean; services?: string[]; probes?: string[]; [key: string]: unknown };
 
 /**
  * Top-level shape of the user's JSON config file. Job toggles live