@stackwright-pro/launch-stackwright-pro 0.4.0-alpha.15 → 0.4.0-alpha.151

package/templates/pro/scripts/pro-content-plugin.js

@@ -0,0 +1,103 @@
+// packages/launch-stackwright-pro/templates/pro/scripts/pro-content-plugin.js
+//
+// Pro content type plugin for @stackwright/build-scripts.
+//
+// CONFIRMED CASE B (@stackwright/build-scripts@0.5.0-alpha.0 / types@1.2.0-alpha.0):
+//   The currently shipped version of build-scripts does NOT read
+//   `contentItemSchemas` or `knownContentTypeKeys` from plugin objects.
+//   Those fields first appear in @stackwright/types@1.4.0+ and will be
+//   consumed by build-scripts@0.7.0 when that release ships.
+//
+// CURRENT BEHAVIOUR (pre-0.7.0):
+//   `unknownContentTypes: 'warn'` in prebuild.js already prevents hard failures
+//   for unrecognised content types. The `beforeBuild` stub below ensures this
+//   plugin is a syntactically valid, callable plugin (not silently ignored by
+//   the plugin runner) even though there is no side-effect to execute yet.
+//
+// TODO(@stackwright/build-scripts@0.7.0): Once 0.7.0 is the resolved floor,
+//   remove the `beforeBuild` stub — `contentItemSchemas` and
+//   `knownContentTypeKeys` will be consumed natively by the runtime and the
+//   plugin will suppress "unknown content type" warnings automatically.
+
+'use strict';
+
+const { z } = require('zod');
+
+const PRO_CONTENT_TYPE_KEYS = [
+  // @stackwright-pro/display-components
+  'metric_card',
+  'status_badge',
+  'stat_bar',
+  'sparkline',
+  'activity_feed',
+  'dashboard_grid',
+  'data_table',
+  'json_viewer',
+  'action_bar',
+  'section',
+  'collection_listing',
+  'detail_field',
+  'detail_view',
+  // @stackwright-pro/pulse
+  'pulse_provider',
+  'metric_card_pulse',
+  'data_table_pulse',
+  'status_badge_pulse',
+  'detail_card_pulse',
+  'stats_grid',
+  'map_pulse',
+  'alert_banner',
+  // @stackwright-pro/workflow-components
+  'workflow_mount',
+  // @stackwright-pro/display-components — navigation
+  'breadcrumb',
+  'page_header_bar',
+];
+
+// OSS content types that Pro otters augment with extra fields (e.g. `theme:`,
+// `auth:`). The strict OSS Zod schemas reject unknown properties, so we
+// register passthrough variants here. When build-scripts@0.7.0+ evaluates
+// the union [contentItemSchema, ...extraSchemas], the strict OSS schema
+// fails on the extra field and falls through to our passthrough version.
+const OSS_TYPES_WITH_PRO_EXTENSIONS = [
+  'text_block',
+  'alert',
+  'grid',
+  'main',
+  'collection_list',
+];
+
+const proContentPlugin = {
+  name: 'pro-content',
+
+  // --- Fields read by build-scripts@0.7.0+ (types@1.4.0+) ---
+  // Passthrough schemas — let each component handle its own prop validation
+  // at runtime. Registered here so the prebuild content-item validator
+  // accepts pro types without errors.
+  contentItemSchemas: [
+    // Pro-only types — fully passthrough (no OSS schema exists)
+    ...PRO_CONTENT_TYPE_KEYS.map((type) =>
+      z.object({ type: z.literal(type) }).passthrough()
+    ),
+    // OSS types with Pro extensions (theme:, auth:, etc.) — passthrough
+    // variants so the extra fields don't fail strict OSS validation.
+    ...OSS_TYPES_WITH_PRO_EXTENSIONS.map((type) =>
+      z.object({ type: z.literal(type) }).passthrough()
+    ),
+  ],
+  // String keys so the prebuild skips "unknown content type" warnings.
+  knownContentTypeKeys: [...PRO_CONTENT_TYPE_KEYS, ...OSS_TYPES_WITH_PRO_EXTENSIONS],
+
+  // --- Stub lifecycle hook (required for build-scripts@0.5.x / types@1.2.x) ---
+  // build-scripts@0.5.x only calls plugins that have beforeBuild or afterBuild.
+  // Without this stub the plugin object is accepted but never invoked, making
+  // the whole registration a silent no-op. The stub has no side-effects; its
+  // only purpose is to keep the plugin in the active lifecycle.
+  //
+  // Remove this stub when build-scripts@0.7.0 is the resolved floor (the
+  // 0.7.x runner calls plugins purely for their schema/key registration,
+  // not via beforeBuild/afterBuild).
+  beforeBuild: () => {},
+};
+
+module.exports = { proContentPlugin };

package/templates/pro/scripts/start-mocks.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+/**
+ * Stackwright Pro — Mock backend launcher.
+ *
+ * Reads public/stackwright-content/_integrations.json and spawns one Prism
+ * mock process per integration that has both `spec` and `mockUrl`.
+ *
+ * Invoked by the `pnpm mock` script, which `pnpm dev:<role>` runs in parallel
+ * with `next dev` via `concurrently`.
+ *
+ * Process management:
+ *   - SIGINT/SIGTERM cleanly shuts down all child Prism processes
+ *   - If a single child exits unexpectedly, it is marked disabled and logged —
+ *     the supervisor keeps running so healthy mocks keep serving (swp-m8et)
+ *   - Only when ALL children have died does the supervisor shut down
+ *   - If no integrations have mockable specs, parent idles (concurrently keeps
+ *     next dev alive while this script waits forever)
+ */
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const INTEGRATIONS_PATH = path.join(
+  process.cwd(),
+  'public',
+  'stackwright-content',
+  '_integrations.json'
+);
+
+function readIntegrations() {
+  if (!fs.existsSync(INTEGRATIONS_PATH)) {
+    console.error(`[mock] ${INTEGRATIONS_PATH} not found. Run prebuild first.`);
+    return [];
+  }
+  try {
+    const raw = fs.readFileSync(INTEGRATIONS_PATH, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.integrations) ? parsed.integrations : [];
+  } catch (err) {
+    console.error('[mock] Failed to parse _integrations.json:', err.message);
+    return [];
+  }
+}
+
+function parsePort(mockUrl) {
+  try {
+    const url = new URL(mockUrl);
+    if (url.port) return url.port;
+    return url.protocol === 'https:' ? '443' : '80';
+  } catch {
+    return null;
+  }
+}
+
+function startPrism(integration) {
+  const { name, spec, mockUrl } = integration;
+  if (!spec || !mockUrl) {
+    console.log(`[mock] Skipping ${name}: no spec or mockUrl in _integrations.json`);
+    return null;
+  }
+  const port = parsePort(mockUrl);
+  if (!port) {
+    console.error(`[mock] ${name}: invalid mockUrl ${mockUrl}`);
+    return null;
+  }
+  const specPath = path.resolve(process.cwd(), spec);
+  if (!fs.existsSync(specPath)) {
+    console.error(`[mock] ${name}: spec file ${specPath} not found`);
+    return null;
+  }
+  console.log(`[mock] Starting ${name} on port ${port} from ${spec}`);
+  // STACKWRIGHT_TEST_MOCK_CMD: test-only override so CI can exercise supervisor
+  // resilience without a working Prism installation (e.g. space-separated args).
+  const spawnArgs = process.env.STACKWRIGHT_TEST_MOCK_CMD
+    ? process.env.STACKWRIGHT_TEST_MOCK_CMD.split(' ')
+    : ['npx', 'prism', 'mock', specPath, '-p', port, '--cors'];
+  const child = spawn(spawnArgs[0], spawnArgs.slice(1), {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    env: process.env,
+  });
+  child.stdout.on('data', (data) => {
+    process.stdout.write(`[${name}] ${data}`);
+  });
+  child.stderr.on('data', (data) => {
+    process.stderr.write(`[${name}] ${data}`);
+  });
+  child.on('exit', (code, signal) => {
+    if (signal === 'SIGTERM' || signal === 'SIGINT') return;
+    console.error(
+      `[mock] WARNING: ${name} died (code=${code}, signal=${signal}) — port ${port} is now unavailable`
+    );
+    deadMocks.add(name);
+    deathToll += 1;
+    if (deathToll >= expectedChildren) {
+      console.error('[mock] All mock children have died — shutting down supervisor.');
+      shutdown(1);
+    }
+  });
+  return child;
+}
+
+const children = [];
+// Tracks names of integrations whose Prism child has died unexpectedly.
+const deadMocks = new Set();
+// Number of Prism children that have died non-signal deaths.
+let deathToll = 0;
+// Set after main() spawns all children so the exit handler knows when everyone is gone.
+let expectedChildren = 0;
+
+function shutdown(exitCode) {
+  console.log('[mock] Shutting down...');
+  for (const child of children) {
+    if (child && !child.killed) {
+      child.kill('SIGTERM');
+    }
+  }
+  setTimeout(() => process.exit(exitCode ?? 0), 500);
+}
+
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+
+function main() {
+  const integrations = readIntegrations();
+  if (integrations.length === 0) {
+    console.log('[mock] No integrations found — idling (concurrently will keep next dev running).');
+    // Keep alive so `concurrently` doesn't treat us as exited
+    setInterval(() => {}, 1 << 30);
+    return;
+  }
+  for (const integration of integrations) {
+    const child = startPrism(integration);
+    if (child) children.push(child);
+  }
+  expectedChildren = children.length;
+  console.log(`[mock] Started ${expectedChildren} mock backend(s).`);
+  if (children.length === 0) {
+    console.log('[mock] No mockable integrations — idling.');
+    setInterval(() => {}, 1 << 30);
+  }
+}
+
+main();