slicejs-cli 3.5.1 → 3.6.0

package/tests/getcomponent.test.js

@@ -1,407 +0,0 @@
-import { test, describe, before, after, mock } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'fs-extra';
-import path from 'path';
-import { createTestProject, cleanupTestProject, withTestProject } from './helpers/setup.js';
-
-describe('runConcurrent', () => {
-  let runConcurrent;
-
-  before(async () => {
-    ({ runConcurrent } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  test('runs all items', async () => {
-    const results = [];
-    const worker = async (item) => { results.push(item); };
-    await runConcurrent([1, 2, 3], worker, 5);
-    assert.deepEqual(results.sort(), [1, 2, 3]);
-  });
-
-  test('respects concurrency limit', async () => {
-    let concurrent = 0;
-    let maxConcurrent = 0;
-    const worker = async (item) => {
-      concurrent++;
-      maxConcurrent = Math.max(maxConcurrent, concurrent);
-      await new Promise(r => setTimeout(r, 10));
-      concurrent--;
-    };
-    await runConcurrent([1, 2, 3, 4, 5], worker, 2);
-    assert.equal(maxConcurrent <= 2, true);
-  });
-
-  test('handles empty array', async () => {
-    const worker = async () => {};
-    await runConcurrent([], worker, 3);
-    assert.ok(true);
-  });
-
-  test('propagates worker errors', async () => {
-    const worker = async () => { throw new Error('worker fail'); };
-    await assert.rejects(() => runConcurrent([1], worker, 3), /worker fail/);
-  });
-
-  test('default concurrency is 3', async () => {
-    let maxConcurrent = 0;
-    let running = 0;
-    const worker = async () => {
-      running++;
-      maxConcurrent = Math.max(maxConcurrent, running);
-      await new Promise(r => setTimeout(r, 10));
-      running--;
-    };
-    await runConcurrent([1, 2, 3, 4, 5], worker);
-    assert.equal(maxConcurrent <= 3, true);
-  });
-});
-
-describe('loadConfig', () => {
-  test('returns config object when sliceConfig.json exists', async () => {
-    await withTestProject(async (tmpDir) => {
-      const { loadConfig } = await import('../commands/getComponent/getComponent.js');
-      const config = await loadConfig();
-      assert.notEqual(config, null);
-      assert.equal(typeof config, 'object');
-      assert.equal(config.server?.port, 3001);
-    });
-  });
-
-  test('returns null when sliceConfig.json is missing', async () => {
-    const tmpDir = await createTestProject();
-    try {
-      process.env.INIT_CWD = tmpDir;
-      const fixtureConfig = new URL('../tests/fixtures/sliceConfig.json', import.meta.url);
-      const fs = await import('node:fs/promises');
-      const path = await import('node:path');
-      const destPath = path.join(tmpDir, 'src', 'sliceConfig.json');
-      try { await fs.unlink(destPath); } catch {}
-      const { loadConfig } = await import('../commands/getComponent/getComponent.js');
-      const config = await loadConfig();
-      assert.equal(config, null);
-    } finally {
-      delete process.env.INIT_CWD;
-      await cleanupTestProject(tmpDir);
-    }
-  });
-});
-
-describe('ComponentRegistry.getAvailableComponents', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  const makeRegistry = (entries) => {
-    const registry = new ComponentRegistry();
-    registry.componentsRegistry = { ...entries };
-    return registry;
-  };
-
-  test('returns empty object when registry not loaded', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.getAvailableComponents();
-    assert.deepEqual(result, {});
-  });
-
-  test('routing components (Route, MultiRoute, Link) return only .js', () => {
-    const registry = makeRegistry({
-      Route: 'Visual',
-      MultiRoute: 'Visual',
-      Link: 'Visual'
-    });
-    const result = registry.getAvailableComponents('Visual');
-    assert.deepEqual(result.Route.files, ['Route.js']);
-    assert.deepEqual(result.MultiRoute.files, ['MultiRoute.js']);
-    assert.deepEqual(result.Link.files, ['Link.js']);
-  });
-
-  test('NotFound returns .js, .html, .css like other visual components', () => {
-    const registry = makeRegistry({
-      NotFound: 'Visual',
-      Button: 'Visual',
-      Navbar: 'Visual'
-    });
-    const result = registry.getAvailableComponents('Visual');
-    assert.deepEqual(result.NotFound.files, ['NotFound.js', 'NotFound.html', 'NotFound.css']);
-    assert.deepEqual(result.Button.files, ['Button.js', 'Button.html', 'Button.css']);
-    assert.deepEqual(result.Navbar.files, ['Navbar.js', 'Navbar.html', 'Navbar.css']);
-  });
-
-  test('Service components return only .js', () => {
-    const registry = makeRegistry({
-      FetchManager: 'Service'
-    });
-    const result = registry.getAvailableComponents('Service');
-    assert.deepEqual(result.FetchManager.files, ['FetchManager.js']);
-  });
-
-  test('filters by category - Visual', () => {
-    const registry = makeRegistry({
-      Button: 'Visual',
-      FetchManager: 'Service'
-    });
-    const result = registry.getAvailableComponents('Visual');
-    assert.ok(result.Button);
-    assert.ok(!result.FetchManager);
-  });
-
-  test('filters by category - Service', () => {
-    const registry = makeRegistry({
-      Button: 'Visual',
-      FetchManager: 'Service'
-    });
-    const result = registry.getAvailableComponents('Service');
-    assert.ok(!result.Button);
-    assert.ok(result.FetchManager);
-  });
-
-  test('returns all categories when no filter', () => {
-    const registry = makeRegistry({
-      Button: 'Visual',
-      FetchManager: 'Service'
-    });
-    const result = registry.getAvailableComponents();
-    assert.ok(result.Button);
-    assert.ok(result.FetchManager);
-  });
-});
-
-describe('fetchWithRetry', () => {
-  let fetchWithRetry;
-  let originalFetch;
-
-  before(async () => {
-    ({ fetchWithRetry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  after(() => {
-    if (originalFetch) globalThis.fetch = originalFetch;
-  });
-
-  test('succeeds on first attempt', async () => {
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = mock.fn(async () => ({
-      ok: true,
-      text: async () => 'response body'
-    }));
-    const result = await fetchWithRetry('https://example.com');
-    assert.equal(result, 'response body');
-    assert.equal(globalThis.fetch.mock.calls.length, 1);
-    globalThis.fetch = originalFetch;
-  });
-
-  test('retries and eventually succeeds', async () => {
-    let attempts = 0;
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = mock.fn(async () => {
-      attempts++;
-      if (attempts < 3) throw new Error('network error');
-      return { ok: true, text: async () => 'success after retry' };
-    });
-    const result = await fetchWithRetry('https://example.com', 3, 5);
-    assert.equal(result, 'success after retry');
-    assert.equal(attempts, 3);
-    globalThis.fetch = originalFetch;
-  });
-
-  test('fails after exhausting retries', async () => {
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = mock.fn(async () => { throw new Error('persistent error'); });
-    await assert.rejects(() => fetchWithRetry('https://example.com', 2, 5), /persistent error/);
-    globalThis.fetch = originalFetch;
-  });
-
-  test('rejects non-ok response', async () => {
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = mock.fn(async () => ({
-      ok: false,
-      status: 404,
-      statusText: 'Not Found'
-    }));
-    await assert.rejects(() => fetchWithRetry('https://example.com', 2, 5), /HTTP 404/);
-    globalThis.fetch = originalFetch;
-  });
-});
-
-describe('filterOfficialComponents', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  test('includes Visual and Service components', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.filterOfficialComponents({
-      Button: 'Visual',
-      FetchManager: 'Service'
-    });
-    assert.deepEqual(result, { Button: 'Visual', FetchManager: 'Service' });
-  });
-
-  test('excludes AppComponents and other categories', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.filterOfficialComponents({
-      Button: 'Visual',
-      AppShell: 'AppComponents',
-      SomeOther: 'Unknown'
-    });
-    assert.deepEqual(result, { Button: 'Visual' });
-  });
-
-  test('returns empty object for empty input', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.filterOfficialComponents({});
-    assert.deepEqual(result, {});
-  });
-
-  test('returns empty when no Visual or Service components', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.filterOfficialComponents({
-      AppShell: 'AppComponents',
-      Custom: 'Other'
-    });
-    assert.deepEqual(result, {});
-  });
-});
-
-describe('findComponentInRegistry', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  const makeRegistry = (entries) => {
-    const registry = new ComponentRegistry();
-    registry.componentsRegistry = { ...entries };
-    return registry;
-  };
-
-  test('finds component by name (case-insensitive)', () => {
-    const registry = makeRegistry({ Button: 'Visual' });
-    const result = registry.findComponentInRegistry('button');
-    assert.deepEqual(result, { name: 'Button', category: 'Visual' });
-  });
-
-  test('returns null for non-existent component', () => {
-    const registry = makeRegistry({ Button: 'Visual' });
-    const result = registry.findComponentInRegistry('NonExistent');
-    assert.equal(result, null);
-  });
-
-  test('returns null when registry not loaded', () => {
-    const registry = new ComponentRegistry();
-    const result = registry.findComponentInRegistry('Button');
-    assert.equal(result, null);
-  });
-
-  test('finds component with exact case', () => {
-    const registry = makeRegistry({ FetchManager: 'Service' });
-    const result = registry.findComponentInRegistry('FetchManager');
-    assert.deepEqual(result, { name: 'FetchManager', category: 'Service' });
-  });
-});
-
-describe('getLocalComponents', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  test('returns components from local components.js', async () => {
-    await withTestProject(async (tmpDir) => {
-      const registry = new ComponentRegistry();
-      const result = await registry.getLocalComponents();
-      assert.deepEqual(result, { Button: 'Visual' });
-    }, { visualComponents: ['Button'] });
-  });
-
-  test('returns empty object when no components.js exists', async () => {
-    const tmpDir = await createTestProject();
-    try {
-      process.env.INIT_CWD = tmpDir;
-      const componentsPath = path.join(tmpDir, 'src', 'Components', 'components.js');
-      await fs.remove(componentsPath);
-      const registry = new ComponentRegistry();
-      const result = await registry.getLocalComponents();
-      assert.deepEqual(result, {});
-    } finally {
-      delete process.env.INIT_CWD;
-      await cleanupTestProject(tmpDir);
-    }
-  });
-
-  test('returns empty object when components.js has invalid format', async () => {
-    const tmpDir = await createTestProject();
-    try {
-      process.env.INIT_CWD = tmpDir;
-      const componentsPath = path.join(tmpDir, 'src', 'Components', 'components.js');
-      await fs.writeFile(componentsPath, 'not valid javascript', 'utf8');
-      const registry = new ComponentRegistry();
-      const result = await registry.getLocalComponents();
-      assert.deepEqual(result, {});
-    } finally {
-      delete process.env.INIT_CWD;
-      await cleanupTestProject(tmpDir);
-    }
-  });
-});
-
-describe('updateLocalRegistrySafe', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  test('registers a new component in components.js', async () => {
-    await withTestProject(async (tmpDir) => {
-      const registry = new ComponentRegistry();
-      await registry.updateLocalRegistrySafe('NewComp', 'Visual');
-      const components = await registry.getLocalComponents();
-      assert.equal(components.NewComp, 'Visual');
-    }, { visualComponents: [] });
-  });
-
-  test('does not duplicate existing component', async () => {
-    await withTestProject(async (tmpDir) => {
-      const registry = new ComponentRegistry();
-      await registry.updateLocalRegistrySafe('Button', 'Visual');
-      const components = await registry.getLocalComponents();
-      assert.equal(components.Button, 'Visual');
-      assert.deepEqual(Object.keys(components).filter(k => k === 'Button'), ['Button']);
-    }, { visualComponents: ['Button'] });
-  });
-});
-
-describe('findUpdatableComponents', () => {
-  let ComponentRegistry;
-
-  before(async () => {
-    ({ ComponentRegistry } = await import('../commands/getComponent/getComponent.js'));
-  });
-
-  test('returns empty when no local components match remote registry', async () => {
-    await withTestProject(async (tmpDir) => {
-      const registry = new ComponentRegistry();
-      registry.componentsRegistry = { SomeRemote: 'Visual' };
-      const result = await registry.findUpdatableComponents();
-      assert.deepEqual(result, []);
-    }, { visualComponents: ['Button'] });
-  });
-
-  test('returns components that exist both locally and remotely', async () => {
-    await withTestProject(async (tmpDir) => {
-      const registry = new ComponentRegistry();
-      registry.componentsRegistry = { Button: 'Visual', FetchManager: 'Service' };
-      const result = await registry.findUpdatableComponents();
-      assert.equal(result.length, 1);
-      assert.equal(result[0].name, 'Button');
-      assert.equal(result[0].category, 'Visual');
-    }, { visualComponents: ['Button'] });
-  });
-});

package/tests/helpers/setup.js

@@ -1,102 +0,0 @@
-import fs from 'fs-extra'
-import path from 'path'
-import os from 'os'
-import { fileURLToPath } from 'url'
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-// Prefer the sibling framework dev repo when present (local monorepo checkout);
-// otherwise fall back to the installed framework package (e.g. CI, where only
-// this repo is checked out). Both ship the same src/ + api/ starter structure.
-const SIBLING_FW = path.resolve(__dirname, '../../../slice.js')
-const PACKAGE_FW = path.resolve(__dirname, '../../node_modules/slicejs-web-framework')
-const FW_DIR = fs.pathExistsSync(SIBLING_FW) ? SIBLING_FW : PACKAGE_FW
-const FIXTURES_DIR = path.resolve(__dirname, '../fixtures')
-
-let counter = 0
-
-export async function createTestProject(options = {}) {
-  const {
-    visualComponents = [],
-    frameworkDir = FW_DIR,
-  } = options
-
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `slice-test-${process.pid}-${counter++}-`))
-
-  const fwExists = await fs.pathExists(frameworkDir)
-  const srcDir = path.join(dir, 'src')
-
-  if (fwExists) {
-    const fwSrc = path.join(frameworkDir, 'src')
-    const fwApi = path.join(frameworkDir, 'api')
-
-    if (await fs.pathExists(fwSrc)) {
-      await fs.copy(fwSrc, srcDir)
-    }
-    if (await fs.pathExists(fwApi)) {
-      await fs.copy(fwApi, path.join(dir, 'api'))
-    }
-  }
-
-  if (!(await fs.pathExists(srcDir))) {
-    await createMinimalScaffold(dir)
-  }
-
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
-
-  if (visualComponents.length > 0) {
-    const registryLines = visualComponents.map(n => `  "${n}": "Visual"`).join(',\n')
-    await fs.writeFile(
-      path.join(srcDir, 'Components', 'components.js'),
-      `const components = {\n${registryLines}\n}; export default components;\n`
-    )
-    for (const name of visualComponents) {
-      const compDir = path.join(srcDir, 'Components', 'Visual', name)
-      await fs.ensureDir(compDir)
-      await fs.writeFile(path.join(compDir, `${name}.js`), `export default class ${name} {}`)
-    }
-  }
-
-  return dir
-}
-
-export async function cleanupTestProject(dir) {
-  await fs.remove(dir)
-}
-
-export async function withTestProject(fn, options = {}) {
-  const dir = await createTestProject(options)
-  const origInitCwd = process.env.INIT_CWD
-  try {
-    process.env.INIT_CWD = dir
-    return await fn(dir)
-  } finally {
-    if (origInitCwd === undefined) {
-      delete process.env.INIT_CWD
-    } else {
-      process.env.INIT_CWD = origInitCwd
-    }
-    await cleanupTestProject(dir)
-  }
-}
-
-async function createMinimalScaffold(dir) {
-  const srcDir = path.join(dir, 'src')
-  await fs.ensureDir(path.join(srcDir, 'App'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'AppComponents', 'AppShell'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Service', 'FetchManager'))
-  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
-  await fs.ensureDir(path.join(srcDir, 'Styles'))
-  await fs.ensureDir(path.join(srcDir, 'Themes'))
-  await fs.ensureDir(path.join(dir, 'api', 'middleware'))
-  await fs.ensureDir(path.join(dir, 'api', 'utils'))
-
-  const fixtureConfig = path.join(FIXTURES_DIR, 'sliceConfig.json')
-  if (await fs.pathExists(fixtureConfig)) {
-    await fs.copy(fixtureConfig, path.join(srcDir, 'sliceConfig.json'))
-  }
-
-  const fixtureComponents = path.join(FIXTURES_DIR, 'components.js')
-  if (await fs.pathExists(fixtureComponents)) {
-    await fs.copy(fixtureComponents, path.join(srcDir, 'Components', 'components.js'))
-  }
-}

package/tests/init-command-contract.test.js

@@ -1,46 +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';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const clientPath = path.join(__dirname, '..', 'client.js');
-const source = fs.readFileSync(clientPath, 'utf-8');
-
-test('init command is registered in client.js', () => {
-  const hasInit = source.includes('.command("init")');
-  assert.ok(hasInit, 'client.js must register an "init" command');
-});
-
-test('init command has a description', () => {
-  const match = source.match(/\.command\(["']init["']\)\s*\.description\(["']([^"']+)["']\)/);
-  assert.ok(match, 'init command must have a .description() call');
-  assert.ok(match[1].length > 0, 'init command description must not be empty');
-});
-
-test('init command has -y / --yes option', () => {
-  const hasShort = source.includes('"-y, --yes');
-  assert.ok(hasShort, 'init command must have a -y/--yes option for non-interactive use');
-});
-
-test('init command action calls initializeProject', () => {
-  const hasCall = source.includes('initializeProject()');
-  assert.ok(hasCall, 'init command action must call initializeProject');
-});
-
-test('init command normalizes project name (lowercase, hyphens)', () => {
-  const hasFilter = source.includes('.toLowerCase()');
-  assert.ok(hasFilter, 'init command must normalize project name to lowercase');
-  assert.ok(source.includes('.replace(/\\s+/g'), 'init command must replace spaces with hyphens');
-});
-
-test('init command validates project name', () => {
-  assert.ok(source.includes("'Project name cannot be empty'"), 'init command must validate non-empty name');
-  assert.ok(source.includes("'Use a simple name, not a path'"), 'init command must reject path separators');
-});
-
-test('init command creates project directory', () => {
-  assert.ok(source.includes('fs.mkdirSync(projectDir'), 'init command must create the project directory');
-  assert.ok(source.includes('process.chdir(projectDir)'), 'init command must chdir into project');
-});

package/tests/local-cli-delegation.test.js

@@ -1,81 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import {
-  findNearestLocalCliEntry,
-  resolveLocalCliCandidate,
-  shouldDelegateToLocalCli,
-  isLocalDelegationDisabled
-} from '../commands/utils/LocalCliDelegation.js';
-
-test('isLocalDelegationDisabled returns true when env flag is set', () => {
-  const env = { SLICE_NO_LOCAL_DELEGATION: '1' };
-  assert.equal(isLocalDelegationDisabled(env), true);
-});
-
-test('isLocalDelegationDisabled returns false when env flag is missing', () => {
-  const env = {};
-  assert.equal(isLocalDelegationDisabled(env), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate is null', () => {
-  assert.equal(shouldDelegateToLocalCli('/tmp/current/client.js', null), false);
-});
-
-test('shouldDelegateToLocalCli is false when candidate realpath equals current realpath', () => {
-  const same = '/tmp/current/client.js';
-  assert.equal(shouldDelegateToLocalCli(same, same), false);
-});
-
-test('shouldDelegateToLocalCli is true when candidate differs from current', () => {
-  const current = '/tmp/global/client.js';
-  const local = '/tmp/project/node_modules/slicejs-cli/client.js';
-  assert.equal(shouldDelegateToLocalCli(current, local), true);
-});
-
-test('findNearestLocalCliEntry returns null when no candidate resolver hits', () => {
-  const cwd = path.join('/tmp', 'slice-nonexistent-project');
-  const resolver = () => null;
-  const result = findNearestLocalCliEntry(cwd, resolver);
-  assert.equal(result, null);
-});
-
-test('findNearestLocalCliEntry returns first match while traversing upward', () => {
-  const cwd = path.resolve('/repo/apps/web/src');
-  const matchDir = path.resolve('/repo/apps/web');
-  const matchResult = path.resolve('/repo/apps/web/node_modules/slicejs-cli/client.js');
-  const calls = [];
-  const resolver = (dir) => {
-    calls.push(dir);
-    if (dir === matchDir) {
-      return matchResult;
-    }
-    return null;
-  };
-
-  const result = findNearestLocalCliEntry(cwd, resolver);
-
-  assert.equal(result, matchResult);
-  assert.deepEqual(calls, [cwd, matchDir]);
-});
-
-test('findNearestLocalCliEntry returns null when resolver is not a function', () => {
-  const result = findNearestLocalCliEntry('/repo/apps/web/src', null);
-  assert.equal(result, null);
-});
-
-test('resolveLocalCliCandidate returns null when candidate path is a directory', () => {
-  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'slice-cli-delegation-'));
-  const candidateDirectory = path.join(tempRoot, 'node_modules', 'slicejs-cli', 'client.js');
-
-  fs.mkdirSync(candidateDirectory, { recursive: true });
-
-  try {
-    const result = resolveLocalCliCandidate(tempRoot);
-    assert.equal(result, null);
-  } finally {
-    fs.rmSync(tempRoot, { recursive: true, force: true });
-  }
-});