@funnelsgrove/cli 0.1.87 → 0.1.89

package/template_scaffold/tests/src/contract/golden/golden-fixtures.test.ts

@@ -1,190 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  CURRENT_STEP_CONTRACT_VERSION,
-  FUNNEL_STEP_TYPES,
-  resolveStepTypeContract,
-  validateFunnelManifestContract,
-  validateFunnelStepMetadataParity,
-  type FunnelContextValue,
-  type FunnelManifest,
-} from '@funnelsgrove/runtime';
-import { publicAnalyticsSdk } from '@funnelsgrove/analytics';
-import { goldenFixture as cancellationOffer } from '../../../../src/contract/golden/cancellation_offer.fixture';
-import { goldenFixture as checkout } from '../../../../src/contract/golden/checkout.fixture';
-import { goldenFixture as purchaseCompleted } from '../../../../src/contract/golden/purchase_completed.fixture';
-import { goldenFixture as formInput } from '../../../../src/contract/golden/form_input.fixture';
-import { goldenFixture as introHero } from '../../../../src/contract/golden/intro_hero.fixture';
-import { goldenFixture as multiSelectChoice } from '../../../../src/contract/golden/multi_select_choice.fixture';
-import { goldenFixture as paywallOffer } from '../../../../src/contract/golden/paywall_offer.fixture';
-import { goldenFixture as progressInterstitial } from '../../../../src/contract/golden/progress_interstitial.fixture';
-import { goldenFixture as singleStepChoice } from '../../../../src/contract/golden/single_step_choice.fixture';
-import { goldenFixture as singleStepChoiceEmoji } from '../../../../src/contract/golden/single_step_choice_emoji.fixture';
-import { goldenFixture as socialProof } from '../../../../src/contract/golden/social_proof.fixture';
-import { goldenFixture as subscriptionHandoff } from '../../../../src/contract/golden/subscription_handoff.fixture';
-import { goldenFixture as subscriptionManagement } from '../../../../src/contract/golden/subscription_management.fixture';
-import { goldenFixture as summaryConfirmation } from '../../../../src/contract/golden/summary_confirmation.fixture';
-import { goldenFixture as upsellOffer } from '../../../../src/contract/golden/upsell_offer.fixture';
-import { goldenFixture as valuePropStory } from '../../../../src/contract/golden/value_prop_story.fixture';
-
-const fixtures = [
-  cancellationOffer,
-  checkout,
-  purchaseCompleted,
-  formInput,
-  introHero,
-  multiSelectChoice,
-  paywallOffer,
-  progressInterstitial,
-  singleStepChoice,
-  singleStepChoiceEmoji,
-  socialProof,
-  subscriptionHandoff,
-  subscriptionManagement,
-  summaryConfirmation,
-  upsellOffer,
-  valuePropStory,
-];
-
-const validationFixtures = [
-  introHero,
-  valuePropStory,
-  singleStepChoice,
-  singleStepChoiceEmoji,
-  multiSelectChoice,
-  formInput,
-  socialProof,
-  progressInterstitial,
-  paywallOffer,
-  upsellOffer,
-  checkout,
-  subscriptionManagement,
-  subscriptionHandoff,
-  cancellationOffer,
-  summaryConfirmation,
-  purchaseCompleted,
-];
-
-const commerceSemanticHelpers = [
-  'trackCheckoutStarted',
-  'trackPaymentInfoSubmitted',
-  'trackCheckoutCompleted',
-] as const satisfies readonly (keyof typeof publicAnalyticsSdk)[];
-const terminalSemanticHelpers = (
-  purchaseCompleted.semanticHelpers
-) satisfies readonly (keyof FunnelContextValue)[];
-
-describe('step contract golden fixtures', () => {
-  it('covers all 16 step types exactly once with component/manifest metadata parity', () => {
-    expect(fixtures).toHaveLength(16);
-    expect(new Set(fixtures.map((fixture) => fixture.stepType)).size).toBe(16);
-    expect(fixtures.map((fixture) => fixture.stepType).sort()).toEqual(
-      FUNNEL_STEP_TYPES.filter((type) => (
-        resolveStepTypeContract(CURRENT_STEP_CONTRACT_VERSION, type)
-      )).sort(),
-    );
-    for (const fixture of fixtures) {
-      expect(fixture.manifestStep.type).toBe(fixture.stepType);
-      expect(fixture.componentMeta).toMatchObject({
-        id: fixture.manifestStep.id,
-        name: fixture.manifestStep.name,
-        type: fixture.manifestStep.type,
-      });
-      expect(fixture.manifestStep.filePath).toMatch(/^src\/steps\/.+\.tsx$/);
-      expect(fixture.manifestStep.componentKey).toBeTruthy();
-      expect(fixture.manifestStep.title).toBeTruthy();
-      expect(fixture.componentMeta.figmaNodeId).toBeTruthy();
-      expect(fixture.componentMeta.title).toBeTruthy();
-      expect(fixture.componentMeta.description).toBeTruthy();
-      expect(validateFunnelStepMetadataParity(
-        fixture.manifestStep,
-        fixture.componentMeta,
-      )).toEqual([]);
-    }
-  });
-
-  it('forms one valid self-contained contract-v3 manifest', () => {
-    const manifest = {
-      templateArchitectureVersion: 1,
-      stepContractVersion: CURRENT_STEP_CONTRACT_VERSION,
-      meta: { title: 'Golden fixture funnel', description: 'Validates all canonical types.' },
-      viewport: { width: 430, height: 932 },
-      assets: {},
-      steps: validationFixtures.map((fixture) => fixture.manifestStep),
-      edgesByStepId: Object.fromEntries(validationFixtures.slice(0, -1).map((fixture, index) => [
-        fixture.manifestStep.id,
-        [{ toStepId: validationFixtures[index + 1].manifestStep.id }],
-      ])),
-      experiments: [],
-    } satisfies FunnelManifest;
-
-    expect(validateFunnelManifestContract(manifest, { mode: 'authoring' })).toEqual([]);
-  });
-
-  it('uses stable scalar and array IDs for choice answers', () => {
-    expect(singleStepChoice.persistedAnswer).toBe('daily');
-    expect(singleStepChoiceEmoji.persistedAnswer).toBe('focused');
-    expect(singleStepChoiceEmoji.options.every((option) => Boolean(option.emoji))).toBe(true);
-    expect(multiSelectChoice.persistedAnswer).toEqual(['sleep', 'focus']);
-    expect(multiSelectChoice.emptyAnswer).toEqual([]);
-    expect(multiSelectChoice.manifestStep.choice.allowEmpty).toBe(true);
-    for (const fixture of [singleStepChoice, singleStepChoiceEmoji, multiSelectChoice]) {
-      expect(fixture.manifestStep.choice.answerKey).toBeTruthy();
-      expect(fixture.helper).toBe('useStepChoices');
-    }
-  });
-
-  it('locks reserved identities and trusted conversion ownership', () => {
-    expect(formInput.manifestStep).toMatchObject({ id: 'email-capture', name: 'email-capture' });
-    expect(formInput.helper).toBe('submitEmailCapture');
-    expect(formInput.forbiddenCalls).toEqual(expect.arrayContaining([
-      'trackLead',
-      'provider APIs',
-      'hard-coded paywall navigation',
-    ]));
-    expect(paywallOffer.manifestStep).toMatchObject({
-      id: 'paywall',
-      name: 'paywall',
-      type: 'paywall_offer',
-      kind: 'paywall',
-    });
-    expect(subscriptionManagement.manifestStep).toMatchObject({
-      id: 'manage-subscription',
-      name: 'manage-subscription',
-      kind: 'manage-subscription',
-    });
-    expect(purchaseCompleted.manifestStep).toMatchObject({
-      id: 'subscription-started',
-      name: 'subscription-started',
-      type: 'purchase_completed',
-      kind: 'subscription-handoff',
-    });
-    expect(purchaseCompleted.forbiddenBrowserEvents).toEqual([
-      'purchase_completed',
-      'registration_completed',
-    ]);
-    expect(terminalSemanticHelpers).toEqual(['completeFunnel']);
-    expect(subscriptionHandoff.isRegistrationCompletion).toBe(false);
-    expect(cancellationOffer.manifestStep.kind).toBe('cancellation');
-    expect(upsellOffer.manifestStep.kind).toBe('upsell');
-  });
-
-  it('uses named checkout helpers only on commerce steps', () => {
-    for (const fixture of [paywallOffer, upsellOffer, checkout]) {
-      expect(fixture.semanticHelpers).toEqual(commerceSemanticHelpers);
-    }
-    expect(typeof publicAnalyticsSdk.trackPaymentInfoSubmitted).toBe('function');
-    expect('trackAddPaymentInfo' in publicAnalyticsSdk).toBe(false);
-    expect(progressInterstitial.semanticHelpers).toEqual([]);
-    expect(progressInterstitial.isPaywall).toBe(false);
-    expect(checkout.requiredEventMetadata).toEqual([
-      'funnelId',
-      'funnelVersionId',
-      'environment',
-      'stepContractVersion',
-      'stepId',
-      'stepName',
-      'stepType',
-      'eventId',
-    ]);
-  });
-});

package/template_scaffold/tests/src/contract/validate-funnel.cli.test.ts

@@ -1,191 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-import {
-  createFunnelContractDiagnostic,
-  CURRENT_STEP_CONTRACT_VERSION,
-  type FunnelContractDiagnostic,
-} from '@funnelsgrove/runtime';
-
-const execFileAsync = promisify(execFile);
-
-const findExecutableOnPath = (name: string): string => {
-  for (const directory of (process.env.PATH || '').split(path.delimiter)) {
-    const candidate = path.join(directory, name);
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(`${name} executable not found on PATH`);
-};
-
-const loadCli = async () => {
-  return import('../../../src/contract/validate-funnel.cli');
-};
-
-const diagnostic = createFunnelContractDiagnostic({
-  code: 'FG-PARITY-001',
-  file: 'src/steps/example.tsx',
-  stepId: 'example',
-  expected: { name: 'example' },
-  received: { name: 'renamed-example' },
-  reason: 'Manifest and component metadata differ.',
-  guide: 'docs/funnelsgrove/contracts/step-metadata.md',
-  repair: 'Restore exact metadata parity.',
-});
-
-type RunResult = {
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-};
-
-const runWith = async (
-  diagnostics: readonly FunnelContractDiagnostic[],
-): Promise<RunResult> => {
-  const cli = await loadCli();
-  let stdout = '';
-  let stderr = '';
-  const exitCode = await cli.runValidateFunnelCli({
-    args: ['--json'],
-    loadValidation: async () => ({
-      contractVersion: cli.VALIDATOR_CONTRACT_VERSION,
-      diagnostics,
-    }),
-    writeStdout: (text: string) => {
-      stdout += text;
-    },
-    writeStderr: (text: string) => {
-      stderr += text;
-    },
-  });
-  return { exitCode, stdout, stderr };
-};
-
-describe('validate funnel CLI protocol', () => {
-  it('writes exactly one JSON object and exits zero for a valid project', async () => {
-    const result = await runWith([]);
-
-    expect(result).toEqual({
-      exitCode: 0,
-      stdout: `${JSON.stringify({
-        schemaVersion: 1,
-        contractVersion: CURRENT_STEP_CONTRACT_VERSION,
-        valid: true,
-        diagnostics: [],
-      })}\n`,
-      stderr: '',
-    });
-    expect(result.stdout.trim().split('\n')).toHaveLength(1);
-  });
-
-  it('preserves blocker diagnostics exactly and renders human detail to stderr', async () => {
-    const result = await runWith([diagnostic]);
-
-    expect(result.exitCode).toBe(1);
-    expect(JSON.parse(result.stdout)).toEqual({
-      schemaVersion: 1,
-      contractVersion: CURRENT_STEP_CONTRACT_VERSION,
-      valid: false,
-      diagnostics: [diagnostic],
-    });
-    expect(result.stderr).toContain('[FG-PARITY-001]');
-    expect(result.stderr).toContain('Manifest and component metadata differ.');
-    expect(result.stderr).toContain('src/steps/example.tsx');
-  });
-
-  it('keeps import log noise off stdout and maps malformed imports to exit two', async () => {
-    const cli = await loadCli();
-    let stdout = '';
-    let stderr = '';
-    const exitCode = await cli.runValidateFunnelCli({
-      args: ['--json'],
-      loadValidation: async () => {
-        process.stdout.write('project import noise\n');
-        throw new Error('malformed project import');
-      },
-      writeStdout: (text: string) => {
-        stdout += text;
-      },
-      writeStderr: (text: string) => {
-        stderr += text;
-      },
-    });
-
-    expect(exitCode).toBe(2);
-    expect(stdout).not.toContain('project import noise');
-    expect(stdout.trim().split('\n')).toHaveLength(1);
-    expect(JSON.parse(stdout)).toMatchObject({
-      schemaVersion: 1,
-      contractVersion: CURRENT_STEP_CONTRACT_VERSION,
-      valid: false,
-      diagnostics: [{
-        code: 'FG-CLIENT-001',
-        severity: 'error',
-      }],
-    });
-    expect(stderr).toContain('project import noise');
-    expect(stderr).toContain('malformed project import');
-  });
-
-  it('rejects unsupported arguments as a protocol error without running imports', async () => {
-    const cli = await loadCli();
-    let loaded = false;
-    let stdout = '';
-    let stderr = '';
-    const exitCode = await cli.runValidateFunnelCli({
-      args: ['--json', '--unknown'],
-      loadValidation: async () => {
-        loaded = true;
-        return { contractVersion: CURRENT_STEP_CONTRACT_VERSION, diagnostics: [] };
-      },
-      writeStdout: (text: string) => {
-        stdout += text;
-      },
-      writeStderr: (text: string) => {
-        stderr += text;
-      },
-    });
-
-    expect(exitCode).toBe(2);
-    expect(loaded).toBe(false);
-    expect(JSON.parse(stdout)).toMatchObject({
-      schemaVersion: 1,
-      contractVersion: CURRENT_STEP_CONTRACT_VERSION,
-      valid: false,
-    });
-    expect(stderr).toContain('Usage: validate-funnel.cli.ts [--json]');
-  });
-
-  it('runs through vite-node with one clean stdout protocol object', async () => {
-    const templateRoot = path.resolve(fileURLToPath(new URL('../../..', import.meta.url)));
-    const viteNode = findExecutableOnPath('vite-node');
-    const script = path.resolve(templateRoot, 'src/contract/validate-funnel.cli.ts');
-
-    const result = await execFileAsync(viteNode, [
-      '--config',
-      'src/contract/funnel-validator.vite.config.ts',
-      script,
-      '--json',
-    ], {
-      cwd: templateRoot,
-      env: {
-        ...process.env,
-        VITE_CJS_IGNORE_WARNING: 'true',
-      },
-      timeout: 20_000,
-    });
-
-    expect(result.stderr).toBe('');
-    expect(result.stdout.trim().split('\n')).toHaveLength(1);
-    expect(JSON.parse(result.stdout)).toEqual({
-      schemaVersion: 1,
-      contractVersion: CURRENT_STEP_CONTRACT_VERSION,
-      valid: true,
-      diagnostics: [],
-    });
-  });
-});

package/template_scaffold/tests/src/runtime/checkout-runtime-config.test.ts

@@ -1,60 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-
-const ORIGINAL_ENV = { ...process.env };
-
-const resetClaimbeeCheckoutEnv = () => {
-  process.env = { ...ORIGINAL_ENV };
-  delete process.env.NEXT_PUBLIC_FUNNEL_PUBLISHABLE_KEY;
-  delete process.env.NEXT_PUBLIC_CLAIMBEE_TEST_STRIPE_PUBLISHABLE_KEY;
-  delete process.env.NEXT_PUBLIC_STRIPE_TEST_PUBLISHABLE_KEY;
-};
-
-describe('checkoutRuntimeConfig', () => {
-  beforeEach(() => {
-    vi.resetModules();
-    resetClaimbeeCheckoutEnv();
-  });
-
-  afterEach(() => {
-    vi.resetModules();
-    process.env = { ...ORIGINAL_ENV };
-  });
-
-  it('does not invent a checkout SDK publishable key from generic Stripe env', async () => {
-    process.env.NEXT_PUBLIC_STRIPE_TEST_PUBLISHABLE_KEY = 'pk_test_generic_runtime_value';
-
-    const { checkoutRuntimeConfig } = await import('../../../src/runtime/checkout-runtime-config');
-
-    expect(checkoutRuntimeConfig.funnelSdkPublishableKey).toBeNull();
-  });
-
-  it('prefers the funnel sdk publishable key when the project runtime provides one', async () => {
-    vi.doMock('@funnelsgrove/runtime', async () => {
-      const actual = await vi.importActual<typeof import('@funnelsgrove/runtime')>(
-        '@funnelsgrove/runtime',
-      );
-
-      return {
-        ...actual,
-        runtimePublicConfig: {
-          ...actual.runtimePublicConfig,
-          funnelSdkPublishableKey: 'sdk_pub_claimbee_project',
-        },
-      };
-    });
-
-    const { checkoutRuntimeConfig, resolveClaimbeeCheckoutMode } = await import('../../../src/runtime/checkout-runtime-config');
-
-    expect(checkoutRuntimeConfig.funnelSdkPublishableKey).toBe(
-      'sdk_pub_claimbee_project',
-    );
-    expect(resolveClaimbeeCheckoutMode('live')).toBe('live');
-  });
-
-  it('uses the server-provided runtime mode when no preview key is injected', async () => {
-    const { resolveClaimbeeCheckoutMode } = await import('../../../src/runtime/checkout-runtime-config');
-
-    expect(resolveClaimbeeCheckoutMode('live')).toBe('live');
-    expect(resolveClaimbeeCheckoutMode('test')).toBe('test');
-  });
-});

package/template_scaffold/tests/src/runtime/funnel-runtime.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { funnelManifest } from '@/config/funnel.manifest';
-import {
-  defaultFunnelStepId,
-  resolveConfiguredNextStep,
-  resolveRuntimeInitialStepId,
-} from '../../../src/runtime/funnel-runtime';
-
-describe('funnel runtime', () => {
-  it('falls back to the first manifest step when no valid step is requested', () => {
-    expect(funnelManifest.steps[0]?.id).toBe(defaultFunnelStepId);
-    expect(resolveRuntimeInitialStepId({ requestedStepId: null })).toBe(defaultFunnelStepId);
-    expect(resolveRuntimeInitialStepId({ requestedStepId: 'missing-step' })).toBe(defaultFunnelStepId);
-  });
-
-  it('resolves the normal edge after an experiment source route is active', () => {
-    expect(
-      resolveConfiguredNextStep('paywall', {
-        attributes: {},
-        ignoreExperiment: true,
-        resolveExperimentVariantKey: () => 'control',
-      }),
-    ).toBe('subscription-started');
-  });
-});

package/template_scaffold/tests/src/runtime/step-content-context.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  getStepContentLocale,
-  getStepCountryCode,
-} from '../../../src/runtime/step-content-context';
-
-describe('step content context helpers', () => {
-  it('prefers stored browser language and explicit country when present', () => {
-    expect(
-      getStepContentLocale(
-        {
-          browserLanguage: 'pt-PT',
-          language: 'en-US',
-        },
-        'de-DE',
-      ),
-    ).toBe('pt-PT');
-
-    expect(
-      getStepCountryCode(
-        {
-          country: 'pt',
-        },
-        'en-US',
-      ),
-    ).toBe('PT');
-  });
-
-  it('falls back to the runtime locale and derives the region when no country is stored', () => {
-    expect(getStepContentLocale({}, 'en-US')).toBe('en-US');
-    expect(getStepCountryCode({}, 'en-US')).toBe('US');
-  });
-
-  it('returns null when no locale or country signal is available', () => {
-    expect(getStepContentLocale({}, null)).toBeNull();
-    expect(getStepCountryCode({}, null)).toBeNull();
-  });
-});