slicejs-cli 3.5.1 → 3.6.0

package/tests/client-update-flow-contract.test.js

@@ -1,272 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parse } from '@babel/parser';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const clientPath = path.join(__dirname, '..', 'client.js');
-const clientSource = fs.readFileSync(clientPath, 'utf-8');
-const ast = parse(clientSource, {
-  sourceType: 'module',
-  errorRecovery: true,
-  loc: true,
-  ranges: true
-});
-
-function lineOf(node) {
-  return node && node.loc && node.loc.start ? node.loc.start.line : null;
-}
-
-function walk(node, visit) {
-  if (!node || typeof node !== 'object') {
-    return;
-  }
-
-  visit(node);
-
-  for (const value of Object.values(node)) {
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        walk(item, visit);
-      }
-      continue;
-    }
-
-    walk(value, visit);
-  }
-}
-
-function isMethodCall(node, methodName) {
-  return (
-    node &&
-    node.type === 'CallExpression' &&
-    node.callee &&
-    node.callee.type === 'MemberExpression' &&
-    node.callee.property &&
-    node.callee.property.type === 'Identifier' &&
-    node.callee.property.name === methodName
-  );
-}
-
-function isCommandUpdateExpression(node) {
-  if (!node || node.type !== 'CallExpression') {
-    return false;
-  }
-
-  if (
-    node.callee &&
-    node.callee.type === 'MemberExpression' &&
-    node.callee.property &&
-    node.callee.property.type === 'Identifier' &&
-    node.callee.property.name === 'command' &&
-    node.arguments[0] &&
-    node.arguments[0].type === 'StringLiteral' &&
-    node.arguments[0].value === 'update'
-  ) {
-    return true;
-  }
-
-  if (node.callee && node.callee.type === 'MemberExpression') {
-    return isCommandUpdateExpression(node.callee.object);
-  }
-
-  return false;
-}
-
-function getRunWithVersionCheckNode() {
-  let foundNode = null;
-
-  walk(ast, (node) => {
-    if (
-      node.type === 'FunctionDeclaration' &&
-      node.id &&
-      node.id.type === 'Identifier' &&
-      node.id.name === 'runWithVersionCheck'
-    ) {
-      foundNode = node;
-      return;
-    }
-
-    if (node.type !== 'VariableDeclarator') {
-      return;
-    }
-
-    if (!node.id || node.id.type !== 'Identifier' || node.id.name !== 'runWithVersionCheck') {
-      return;
-    }
-
-    if (
-      node.init &&
-      (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')
-    ) {
-      foundNode = node.init;
-    }
-  });
-
-  return foundNode;
-}
-
-function getFunctionBodyNode(fnNode) {
-  if (!fnNode) {
-    return null;
-  }
-
-  if (fnNode.type === 'FunctionDeclaration' || fnNode.type === 'FunctionExpression' || fnNode.type === 'ArrowFunctionExpression') {
-    return fnNode.body;
-  }
-
-  return null;
-}
-
-function getFunctionLikeByName(name) {
-  let foundNode = null;
-
-  walk(ast, (node) => {
-    if (
-      node.type === 'FunctionDeclaration' &&
-      node.id &&
-      node.id.type === 'Identifier' &&
-      node.id.name === name
-    ) {
-      foundNode = node;
-      return;
-    }
-
-    if (node.type !== 'VariableDeclarator') {
-      return;
-    }
-
-    if (!node.id || node.id.type !== 'Identifier' || node.id.name !== name) {
-      return;
-    }
-
-    if (
-      node.init &&
-      (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression')
-    ) {
-      foundNode = node.init;
-    }
-  });
-
-  return foundNode;
-}
-
-test('runWithVersionCheck uses non-blocking update notifications', () => {
-  const runWithVersionCheckNode = getRunWithVersionCheckNode();
-  const runWithVersionCheckBody = getFunctionBodyNode(runWithVersionCheckNode);
-
-  assert.ok(
-    runWithVersionCheckNode,
-    'runWithVersionCheck function should exist as a declaration or function-valued variable'
-  );
-  assert.ok(runWithVersionCheckBody, 'runWithVersionCheck should have a traversable function body');
-
-  let hasNotifyCall = false;
-  let hasAwaitedNotifyCall = false;
-  let notifyCallLine = null;
-  let hasPromptCall = false;
-  let promptCallLine = null;
-
-  walk(runWithVersionCheckBody, (node) => {
-    if (isMethodCall(node, 'notifyAvailableUpdates')) {
-      hasNotifyCall = true;
-      notifyCallLine = notifyCallLine ?? lineOf(node);
-    }
-    if (
-      node.type === 'AwaitExpression' &&
-      isMethodCall(node.argument, 'notifyAvailableUpdates')
-    ) {
-      hasAwaitedNotifyCall = true;
-    }
-    if (isMethodCall(node, 'checkAndPromptUpdates')) {
-      hasPromptCall = true;
-      promptCallLine = promptCallLine ?? lineOf(node);
-    }
-  });
-
-  assert.equal(
-    hasNotifyCall,
-    true,
-    `runWithVersionCheck must call updateManager.notifyAvailableUpdates() (found at line ${notifyCallLine ?? 'unknown'})`
-  );
-  assert.equal(
-    hasAwaitedNotifyCall,
-    false,
-    `runWithVersionCheck should fire-and-forget notifyAvailableUpdates() without await (notify call line ${notifyCallLine ?? 'unknown'})`
-  );
-  assert.equal(
-    hasPromptCall,
-    false,
-    `runWithVersionCheck must not call updateManager.checkAndPromptUpdates() (found at line ${promptCallLine ?? 'unknown'})`
-  );
-});
-
-test('update command remains explicitly interactive', () => {
-  let foundAwaitedInteractiveUpdateAction = false;
-  let updateActionHandlerLine = null;
-  let relatedPromptCallLine = null;
-  let handlerReferenceName = null;
-
-  walk(ast, (node) => {
-    if (
-      node.type === 'CallExpression' &&
-      node.callee &&
-      node.callee.type === 'MemberExpression' &&
-      node.callee.property &&
-      node.callee.property.type === 'Identifier' &&
-      node.callee.property.name === 'action' &&
-      isCommandUpdateExpression(node.callee.object)
-    ) {
-      const actionHandler = node.arguments[0];
-      if (!actionHandler) {
-        return;
-      }
-
-      let resolvedHandler = null;
-
-      if (actionHandler.type === 'Identifier') {
-        handlerReferenceName = actionHandler.name;
-        resolvedHandler = getFunctionLikeByName(actionHandler.name);
-      } else if (
-        actionHandler.type === 'ArrowFunctionExpression' ||
-        actionHandler.type === 'FunctionExpression'
-      ) {
-        resolvedHandler = actionHandler;
-      }
-
-      if (!resolvedHandler || resolvedHandler.async !== true) {
-        return;
-      }
-
-      const resolvedBody = getFunctionBodyNode(resolvedHandler);
-      if (!resolvedBody) {
-        return;
-      }
-
-      updateActionHandlerLine = updateActionHandlerLine ?? lineOf(resolvedHandler);
-
-      walk(resolvedBody, (actionNode) => {
-        if (isMethodCall(actionNode, 'checkAndPromptUpdates')) {
-          relatedPromptCallLine = relatedPromptCallLine ?? lineOf(actionNode);
-        }
-
-        if (
-          actionNode.type !== 'AwaitExpression' ||
-          !isMethodCall(actionNode.argument, 'checkAndPromptUpdates')
-        ) {
-          return;
-        }
-
-        foundAwaitedInteractiveUpdateAction = true;
-      });
-    }
-  });
-
-  assert.equal(
-    foundAwaitedInteractiveUpdateAction,
-    true,
-    `update command action must await checkAndPromptUpdates(...) (action line ${updateActionHandlerLine ?? 'unknown'}, related call line ${relatedPromptCallLine ?? 'unknown'}${handlerReferenceName ? `, handler reference ${handlerReferenceName}` : ''})`
-  );
-});

package/tests/commands-component-crud.test.js

@@ -1,102 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs-extra';
-import path from 'node:path';
-import { withTestProject } from './helpers/setup.js';
-import createComponent from '../commands/createComponent/createComponent.js';
-import deleteComponent from '../commands/deleteComponent/deleteComponent.js';
-import listComponentsReal from '../commands/listComponents/listComponents.js';
-
-const visualDir = (root, name) =>
-  path.join(root, 'src', 'Components', 'Visual', name);
-
-describe('component create', () => {
-  test('creates a Visual component with .js/.css/.html', async () => {
-    await withTestProject(async (root) => {
-      const ok = createComponent('Card', 'Visual');
-      assert.equal(ok, true);
-      const dir = visualDir(root, 'Card');
-      assert.ok(await fs.pathExists(path.join(dir, 'Card.js')));
-      assert.ok(await fs.pathExists(path.join(dir, 'Card.css')));
-      assert.ok(await fs.pathExists(path.join(dir, 'Card.html')));
-    });
-  });
-
-  test('creates a Service component with only a .js file', async () => {
-    await withTestProject(async (root) => {
-      const ok = createComponent('Api', 'Service');
-      assert.equal(ok, true);
-      const dir = path.join(root, 'src', 'Components', 'Service', 'Api');
-      assert.ok(await fs.pathExists(path.join(dir, 'Api.js')));
-      assert.equal(await fs.pathExists(path.join(dir, 'Api.css')), false);
-    });
-  });
-
-  test('rejects an invalid component name', async () => {
-    await withTestProject(() => {
-      assert.equal(createComponent('1Bad', 'Visual'), false);
-      assert.equal(createComponent('bad-name', 'Visual'), false);
-    });
-  });
-
-  test('rejects an unknown category', async () => {
-    await withTestProject(() => {
-      assert.equal(createComponent('Card', 'Nope'), false);
-    });
-  });
-
-  test('rejects when the component files already exist', async () => {
-    await withTestProject(() => {
-      assert.equal(createComponent('Card', 'Visual'), true);
-      // Second creation hits the on-disk existence guard.
-      assert.equal(createComponent('Card', 'Visual'), false);
-    });
-  });
-});
-
-describe('component delete', () => {
-  test('deletes an existing component directory', async () => {
-    await withTestProject(async (root) => {
-      createComponent('Card', 'Visual');
-      assert.ok(await fs.pathExists(visualDir(root, 'Card')));
-
-      const ok = deleteComponent('Card', 'Visual');
-      assert.equal(ok, true);
-      assert.equal(await fs.pathExists(visualDir(root, 'Card')), false);
-    });
-  });
-
-  test('returns false when the component does not exist', async () => {
-    await withTestProject(() => {
-      assert.equal(deleteComponent('DoesNotExist', 'Visual'), false);
-    });
-  });
-
-  // Components are PascalCase by convention: both create and delete normalize
-  // the initial to uppercase, so a lower-case name round-trips correctly.
-  test('create/delete round-trips a lower-case initial (PascalCase normalization)', async () => {
-    await withTestProject(async (root) => {
-      assert.equal(createComponent('card', 'Visual'), true);
-      assert.ok(await fs.pathExists(visualDir(root, 'Card')), 'folder is created in PascalCase');
-      assert.equal(deleteComponent('card', 'Visual'), true);
-      assert.equal(await fs.pathExists(visualDir(root, 'Card')), false);
-    });
-  });
-});
-
-describe('component list (registry regeneration)', () => {
-  test('regenerates components.js from the files on disk', async () => {
-    await withTestProject(async (root) => {
-      createComponent('Card', 'Visual');
-      listComponentsReal();
-
-      const registryPath = path.join(root, 'src', 'Components', 'components.js');
-      const content = await fs.readFile(registryPath, 'utf8');
-      const json = JSON.parse(content.match(/const components = ({[\s\S]*?});/)[1]);
-
-      assert.equal(json.Card, 'Visual');
-      // Starter AppComponents must still be present.
-      assert.equal(json.AppShell, 'AppComponents');
-    });
-  });
-});

package/tests/commands-doctor.test.js

@@ -1,80 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs-extra';
-import path from 'node:path';
-import { withTestProject } from './helpers/setup.js';
-import {
-  checkNodeVersion,
-  checkDirectoryStructure,
-  checkConfig,
-  checkComponents,
-} from '../commands/doctor/doctor.js';
-
-describe('doctor checks', () => {
-  test('checkNodeVersion passes on the supported runtime', async () => {
-    const r = await checkNodeVersion();
-    assert.equal(r.pass, true);
-    assert.match(r.message, /Node\.js version/);
-  });
-
-  test('checkDirectoryStructure passes on the starter project', async () => {
-    await withTestProject(async () => {
-      const r = await checkDirectoryStructure();
-      assert.equal(r.pass, true);
-    });
-  });
-
-  test('checkDirectoryStructure fails when src/ is missing', async () => {
-    await withTestProject(async (root) => {
-      await fs.remove(path.join(root, 'src'));
-      const r = await checkDirectoryStructure();
-      assert.equal(r.pass, false);
-      assert.match(r.message, /Missing directories/);
-      assert.match(r.message, /src\//);
-    });
-  });
-
-  test('checkConfig passes for a valid sliceConfig.json', async () => {
-    await withTestProject(async () => {
-      const r = await checkConfig();
-      assert.equal(r.pass, true);
-    });
-  });
-
-  test('checkConfig fails on invalid JSON', async () => {
-    await withTestProject(async (root) => {
-      await fs.writeFile(path.join(root, 'src', 'sliceConfig.json'), '{ not valid json ');
-      const r = await checkConfig();
-      assert.equal(r.pass, false);
-      assert.match(r.message, /invalid JSON/);
-    });
-  });
-
-  test('checkConfig fails when paths.components is missing', async () => {
-    await withTestProject(async (root) => {
-      await fs.writeJson(path.join(root, 'src', 'sliceConfig.json'), { server: { port: 3000 } });
-      const r = await checkConfig();
-      assert.equal(r.pass, false);
-      assert.match(r.message, /missing paths\.components/);
-    });
-  });
-
-  test('checkComponents reports OK when every component folder has its .js', async () => {
-    await withTestProject(async () => {
-      const r = await checkComponents();
-      assert.equal(r.pass, true);
-      assert.match(r.message, /components checked/);
-    });
-  });
-
-  test('checkComponents warns when a component folder lacks its .js file', async () => {
-    await withTestProject(async (root) => {
-      // AppShell ships with AppShell.js; remove it to simulate a broken component.
-      const broken = path.join(root, 'src', 'Components', 'AppComponents', 'Broken');
-      await fs.ensureDir(broken); // directory with no Broken.js
-      const r = await checkComponents();
-      assert.equal(r.warn, true);
-      assert.match(r.message, /missing files/);
-    });
-  });
-});

package/tests/commands-version-checker.test.js

@@ -1,37 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import versionChecker from '../commands/utils/VersionChecker.js';
-
-describe('VersionChecker.compareVersions', () => {
-  test('detects an outdated version', () => {
-    assert.equal(versionChecker.compareVersions('1.0.0', '1.0.1'), 'outdated');
-    assert.equal(versionChecker.compareVersions('1.2.0', '2.0.0'), 'outdated');
-  });
-
-  test('detects a newer (local) version', () => {
-    assert.equal(versionChecker.compareVersions('2.0.0', '1.9.9'), 'newer');
-  });
-
-  test('detects an up-to-date version', () => {
-    assert.equal(versionChecker.compareVersions('3.5.0', '3.5.0'), 'current');
-  });
-
-  test('handles version strings of differing length', () => {
-    assert.equal(versionChecker.compareVersions('1.0', '1.0.0'), 'current');
-    assert.equal(versionChecker.compareVersions('1.0.0', '1.0.0.1'), 'outdated');
-    assert.equal(versionChecker.compareVersions('1.0.1', '1.0'), 'newer');
-  });
-
-  test('returns null when a version is missing', () => {
-    assert.equal(versionChecker.compareVersions(null, '1.0.0'), null);
-    assert.equal(versionChecker.compareVersions('1.0.0', undefined), null);
-  });
-});
-
-describe('VersionChecker.getCurrentVersions', () => {
-  test('reads the CLI version from the package.json (no network)', async () => {
-    const current = await versionChecker.getCurrentVersions();
-    assert.ok(current, 'should resolve current versions');
-    assert.match(current.cli, /^\d+\.\d+\.\d+/);
-  });
-});

package/tests/component-registry-parse.test.js

@@ -1,34 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { createTestProject, cleanupTestProject, withTestProject } from './helpers/setup.js';
-
-test('generateTypesFile parses JSON from components.js (no eval)', async () => {
-  const tmpRoot = await createTestProject({ visualComponents: ['Button'] });
-
-  try {
-    const srcDir = path.join(tmpRoot, 'src');
-    const { generateTypesFile } = await import('../commands/types/types.js');
-    const result = await generateTypesFile({
-      projectRoot: tmpRoot,
-      outputPath: path.join(srcDir, 'slice-build.generated.d.ts')
-    });
-
-    assert.ok(result.componentsProcessed > 0);
-    assert.equal(fs.existsSync(result.outputPath), true);
-
-    const declaration = fs.readFileSync(result.outputPath, 'utf8');
-    assert.match(declaration, /export interface ButtonProps/);
-  } finally {
-    await cleanupTestProject(tmpRoot);
-  }
-});
-
-test('Validations componentExists with JSON.parse (no eval)', async () => {
-  await withTestProject(async (tmpDir) => {
-    const validations = (await import('../commands/Validations.js')).default;
-    assert.equal(validations.componentExists('Button'), true);
-    assert.equal(validations.componentExists('NonExistent'), false);
-  }, { visualComponents: ['Button'] });
-});

package/tests/dependency-analyzer.test.js

@@ -1,24 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import DependencyAnalyzer from '../commands/utils/bundling/DependencyAnalyzer.js';
-
-test('parseComponentsConfig returns components map', () => {
-  // Arrange
-  const analyzer = new DependencyAnalyzer(import.meta.url);
-  const content = `const components = {"Button": "Visual", "FetchManager": "Service"};\nexport default components;`;
-
-  // Act
-  const result = analyzer.parseComponentsConfig(content);
-
-  // Assert
-  assert.deepEqual(result, { Button: 'Visual', FetchManager: 'Service' });
-});
-
-test('parseComponentsConfig throws for invalid config', () => {
-  // Arrange
-  const analyzer = new DependencyAnalyzer(import.meta.url);
-  const content = `const notComponents = {"Button": "Visual"};`;
-
-  // Act / Assert
-  assert.throws(() => analyzer.parseComponentsConfig(content), /components object not found/);
-});

package/tests/e2e/bundles.spec.js

@@ -1,91 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { parse } from '@babel/parser';
-
-// Recursively collect every emitted bundle file referenced by the config.
-// Only real bundle artifacts (slice-bundle.*.js) — not dependency identifiers
-// that happen to end in `.js` (e.g. vendorShared.dependencies).
-function collectBundleFiles(node, acc = new Set()) {
-  if (typeof node === 'string') {
-    if (node.startsWith('slice-bundle.') && node.endsWith('.js')) acc.add(node);
-    return acc;
-  }
-  if (Array.isArray(node)) {
-    for (const n of node) collectBundleFiles(n, acc);
-    return acc;
-  }
-  if (node && typeof node === 'object') {
-    for (const v of Object.values(node)) collectBundleFiles(v, acc);
-    return acc;
-  }
-  return acc;
-}
-
-async function getConfig(request) {
-  const res = await request.get('/bundles/bundle.config.json');
-  expect(res.status()).toBe(200);
-  return res.json();
-}
-
-test.describe('bundle quality & content (served production artifacts)', () => {
-  test('bundle.config.json is well-formed and maps every route', async ({ request }) => {
-    const cfg = await getConfig(request);
-    expect(cfg.production).toBe(true);
-    expect(cfg.format).toBe('v2');
-    expect(cfg.minified).toBe(true);
-    expect(cfg.obfuscated).toBe(true);
-    expect(cfg.bundles.framework, 'framework bundle present').toBeTruthy();
-    expect(cfg.bundles.critical, 'critical bundle present').toBeTruthy();
-
-    for (const route of ['/', '/about', '/404']) {
-      expect(Array.isArray(cfg.routeBundles[route]), `route ${route} is mapped`).toBe(true);
-      expect(cfg.routeBundles[route].length).toBeGreaterThan(0);
-    }
-  });
-
-  test('every referenced bundle is served as valid, contract-compliant JS', async ({ request }) => {
-    const cfg = await getConfig(request);
-    const files = [...collectBundleFiles(cfg.bundles)];
-    expect(files.length).toBeGreaterThan(0);
-
-    for (const file of files) {
-      const res = await request.get(`/bundles/${file}`);
-      expect(res.status(), `${file} is served`).toBe(200);
-      expect(res.headers()['content-type'] || '').toMatch(/javascript/);
-
-      const code = await res.text();
-      expect(() => parse(code, { sourceType: 'module', plugins: ['jsx'] }), `${file} is valid JS`).not.toThrow();
-      // v2 runtime contract.
-      expect(code, `${file} exports SLICE_BUNDLE_META`).toContain('SLICE_BUNDLE_META');
-      expect(code, `${file} exports registerAll`).toContain('registerAll');
-      // No unresolved relative import may leak into a production bundle.
-      expect(/\bfrom\s+['"]\.\.?\//.test(code), `${file} leaks a relative import`).toBe(false);
-    }
-  });
-
-  test('the framework bundle carries the structural runtime', async ({ request }) => {
-    const code = await (await request.get('/bundles/slice-bundle.framework.js')).text();
-    expect(code).toContain('Controller');
-    expect(code).toContain('registerAll');
-  });
-
-  test('all starter component classes are registered across the bundles', async ({ request }) => {
-    const cfg = await getConfig(request);
-    const files = [...collectBundleFiles(cfg.bundles)];
-    let combined = '';
-    for (const file of files) {
-      combined += await (await request.get(`/bundles/${file}`)).text();
-    }
-    // Component names are emitted as string literals in the register* calls and
-    // survive minification (mangle.properties is off, strings are untouched).
-    for (const comp of ['AppShell', 'Navbar', 'MultiRoute', 'HomeSection', 'Button', 'AboutSection', 'NotFound']) {
-      expect(combined.includes(`"${comp}"`), `${comp} is registered in a bundle`).toBe(true);
-    }
-  });
-
-  test('bundles are genuinely minified', async ({ request }) => {
-    const code = await (await request.get('/bundles/slice-bundle.framework.js')).text();
-    const longestLine = Math.max(...code.split('\n').map((l) => l.length));
-    expect(longestLine, 'minified output has long lines').toBeGreaterThan(300);
-    expect(code, 'comments are stripped').not.toContain('/**');
-  });
-});