nebula-cms 0.1.0

package/tests/astro/index.test.ts

@@ -0,0 +1,689 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+} from 'node:fs';
+import { resolve, join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+import NebulaCMS, { nebulaVitePlugin } from '../../src/astro/index.js';
+import type { AstroIntegrationLogger } from 'astro';
+
+/*
+//////////////////////////////
+// Test Helpers
+//////////////////////////////
+*/
+
+/**
+ * Creates a minimal mock satisfying the AstroIntegrationLogger interface
+ * @return {AstroIntegrationLogger} Mock logger with a spied warn method
+ */
+function createMockLogger() {
+  return { warn: vi.fn() } as unknown as AstroIntegrationLogger;
+}
+
+/*
+//////////////////////////////
+// NebulaCMS integration object
+//////////////////////////////
+*/
+
+describe('NebulaCMS integration object', () => {
+  it('returns an integration with name "nebula-cms"', () => {
+    const integration = NebulaCMS();
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('registers a Vite plugin via astro:config:setup', () => {
+    const integration = NebulaCMS();
+    const updateConfig = vi.fn();
+    const logger = createMockLogger();
+
+    const hook = integration.hooks['astro:config:setup'] as Function;
+    hook({ updateConfig, logger });
+
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [expect.objectContaining({ name: 'vite-plugin-nebula-cms' })],
+        worker: { format: 'es' },
+        optimizeDeps: { include: ['smol-toml'] },
+      },
+    });
+  });
+
+  it('accepts a valid absolute basePath', () => {
+    const integration = NebulaCMS({ basePath: '/dashboard' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('normalizes basePath without leading slash', () => {
+    // Should not throw — 'admin' is normalized to '/admin'
+    const integration = NebulaCMS({ basePath: 'admin' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('normalizes basePath with trailing slash', () => {
+    // Should not throw — '/admin/' is normalized to '/admin'
+    const integration = NebulaCMS({ basePath: '/admin/' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('throws on basePath with invalid characters', () => {
+    expect(() => NebulaCMS({ basePath: '/admin/<script>' })).toThrow(
+      'Invalid basePath',
+    );
+  });
+
+  it('accepts a valid absolute collectionsPath', () => {
+    const integration = NebulaCMS({ collectionsPath: '/schemas' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('normalizes collectionsPath without leading slash', () => {
+    const integration = NebulaCMS({ collectionsPath: 'schemas' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('normalizes collectionsPath with trailing slash', () => {
+    const integration = NebulaCMS({ collectionsPath: '/schemas/' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('throws on collectionsPath with invalid characters', () => {
+    expect(() => NebulaCMS({ collectionsPath: '/my schemas' })).toThrow(
+      'Invalid collectionsPath',
+    );
+  });
+
+  it('throws on empty collectionsPath', () => {
+    expect(() => NebulaCMS({ collectionsPath: '' })).toThrow(
+      'Invalid collectionsPath',
+    );
+  });
+
+  it('accepts root basePath /', () => {
+    const integration = NebulaCMS({ basePath: '/' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('collapses consecutive slashes in basePath', () => {
+    // '/admin//' is normalized to '/admin' via URL API
+    const integration = NebulaCMS({ basePath: '/admin//' });
+    expect(integration.name).toBe('nebula-cms');
+  });
+
+  it('throws on empty basePath', () => {
+    expect(() => NebulaCMS({ basePath: '' })).toThrow('Invalid basePath ""');
+  });
+
+  it('throws on collectionsPath set to /', () => {
+    expect(() => NebulaCMS({ collectionsPath: '/' })).toThrow(
+      'Collections require a path prefix',
+    );
+  });
+
+  it('throws on protocol-relative basePath', () => {
+    expect(() => NebulaCMS({ basePath: '//admin' })).toThrow(
+      'must not start with "//"',
+    );
+  });
+});
+
+/*
+//////////////////////////////
+// resolveId hook
+//////////////////////////////
+*/
+
+describe('nebulaVitePlugin resolveId', () => {
+  it('resolves virtual:nebula/collections to the internal ID', () => {
+    const plugin = nebulaVitePlugin(createMockLogger(), '/fake', {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    expect(plugin.resolveId('virtual:nebula/collections')).toBe(
+      '\0virtual:nebula/collections',
+    );
+  });
+
+  it('resolves virtual:nebula/config to the internal ID', () => {
+    const plugin = nebulaVitePlugin(createMockLogger(), '/fake', {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    expect(plugin.resolveId('virtual:nebula/config')).toBe(
+      '\0virtual:nebula/config',
+    );
+  });
+
+  it('returns undefined for unrelated module IDs', () => {
+    const plugin = nebulaVitePlugin(createMockLogger(), '/fake', {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    expect(plugin.resolveId('some-other-module')).toBeUndefined();
+  });
+
+  it('does not resolve old virtual:collections ID', () => {
+    const plugin = nebulaVitePlugin(createMockLogger(), '/fake', {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    expect(plugin.resolveId('virtual:collections')).toBeUndefined();
+  });
+});
+
+/*
+//////////////////////////////
+// configureServer middleware
+//////////////////////////////
+*/
+
+describe('nebulaVitePlugin configureServer', () => {
+  let tmpDir: string;
+  let logger: AstroIntegrationLogger;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'nebula-test-'));
+    logger = createMockLogger();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Creates a fake Connect-style middleware stack to capture registered handlers.
+   * @return {{ use: ReturnType<typeof vi.fn>, handlers: Function[] }}
+   */
+  function createMiddlewareStub() {
+    const handlers: Function[] = [];
+    return {
+      use: vi.fn((fn: Function) => {
+        handlers.push(fn);
+      }),
+      get handlers() {
+        return handlers;
+      },
+    };
+  }
+
+  /**
+   * Simulates a middleware request/response cycle for the schema middleware.
+   * @param {Function} handler - The middleware handler
+   * @param {string} url - The request URL
+   * @return {{ status: 'served' | 'skipped', body?: string, contentType?: string }}
+   */
+  function callSchemaMiddleware(handler: Function, url: string) {
+    let result: { status: string; body?: string; contentType?: string } = {
+      status: 'skipped',
+    };
+    const req = { url };
+    const headers: Record<string, string> = {};
+    const res = {
+      setHeader: (k: string, v: string) => {
+        headers[k] = v;
+      },
+      end: (body: string) => {
+        result = {
+          status: 'served',
+          body,
+          contentType: headers['Content-Type'],
+        };
+      },
+    };
+    const next = () => {
+      result = { status: 'skipped' };
+    };
+    handler(req, res, next);
+    return result;
+  }
+
+  /**
+   * Simulates a middleware request/response cycle for the SPA rewrite middleware.
+   * @param {Function} handler - The middleware handler
+   * @param {string} url - The request URL
+   * @param {string} accept - The Accept header value
+   * @return {{ rewritten: boolean, url: string, nextCalled: boolean }}
+   */
+  function callRewriteMiddleware(
+    handler: Function,
+    url: string,
+    accept: string,
+  ) {
+    const req = { url, headers: { accept } };
+    let nextCalled = false;
+    const next = () => {
+      nextCalled = true;
+    };
+    handler(req, {}, next);
+    return { rewritten: req.url !== url, url: req.url, nextCalled };
+  }
+
+  it('serves schema files from .astro/collections', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{"type":"object"}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    // First handler is the schema middleware
+    const result = callSchemaMiddleware(
+      mw.handlers[0],
+      '/collections/posts.schema.json',
+    );
+    expect(result.status).toBe('served');
+    expect(result.body).toBe('{"type":"object"}');
+    expect(result.contentType).toBe('application/json');
+  });
+
+  it('calls next() for non-schema requests', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callSchemaMiddleware(mw.handlers[0], '/some/other/path');
+    expect(result.status).toBe('skipped');
+  });
+
+  it('calls next() when schema file does not exist', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callSchemaMiddleware(
+      mw.handlers[0],
+      '/collections/missing.schema.json',
+    );
+    expect(result.status).toBe('skipped');
+  });
+
+  it('uses custom collectionsPath prefix', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/schemas',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const miss = callSchemaMiddleware(
+      mw.handlers[0],
+      '/collections/posts.schema.json',
+    );
+    expect(miss.status).toBe('skipped');
+
+    const hit = callSchemaMiddleware(
+      mw.handlers[0],
+      '/schemas/posts.schema.json',
+    );
+    expect(hit.status).toBe('served');
+  });
+
+  it('rewrites HTML requests under basePath to basePath', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    // Second handler is the SPA rewrite middleware
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/admin/posts/my-article',
+      'text/html',
+    );
+    expect(result.rewritten).toBe(true);
+    expect(result.url).toBe('/admin');
+  });
+
+  it('does not rewrite exact basePath requests', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(mw.handlers[1], '/admin', 'text/html');
+    expect(result.rewritten).toBe(false);
+  });
+
+  it('does not rewrite non-HTML requests under basePath', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/admin/posts/my-article',
+      'application/json',
+    );
+    expect(result.rewritten).toBe(false);
+  });
+
+  it('respects segment boundary — /administrator does not rewrite', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/administrator',
+      'text/html',
+    );
+    expect(result.rewritten).toBe(false);
+  });
+
+  it('rewrites with custom basePath', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/nebula',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/nebula/posts/draft-12345678',
+      'text/html',
+    );
+    expect(result.rewritten).toBe(true);
+    expect(result.url).toBe('/nebula');
+  });
+
+  it('rewrites sub-routes when basePath is /', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/posts/my-article',
+      'text/html',
+    );
+    expect(result.rewritten).toBe(true);
+    expect(result.url).toBe('/');
+  });
+
+  it('does not rewrite root path when basePath is /', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(mw.handlers[1], '/', 'text/html');
+    expect(result.rewritten).toBe(false);
+  });
+
+  it('rewrites HTML requests with query strings', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callRewriteMiddleware(
+      mw.handlers[1],
+      '/admin/posts?draft=true',
+      'text/html',
+    );
+    expect(result.rewritten).toBe(true);
+    // Query string preserved during rewrite
+    expect(result.url).toBe('/admin?draft=true');
+  });
+
+  it('rejects path traversal in schema requests', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const mw = createMiddlewareStub();
+    plugin.configureServer({ middlewares: mw });
+
+    const result = callSchemaMiddleware(
+      mw.handlers[0],
+      '/collections/../../../etc/passwd.schema.json',
+    );
+    expect(result.status).toBe('skipped');
+  });
+});
+
+/*
+//////////////////////////////
+// astro:build:done hook
+//////////////////////////////
+*/
+
+describe('NebulaCMS astro:build:done', () => {
+  let tmpDir: string;
+  let logger: AstroIntegrationLogger;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'nebula-test-'));
+    logger = createMockLogger();
+    vi.spyOn(process, 'cwd').mockReturnValue(tmpDir);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('copies schema files into the build output directory', () => {
+    const source = resolve(tmpDir, '.astro/collections');
+    mkdirSync(source, { recursive: true });
+    writeFileSync(resolve(source, 'posts.schema.json'), '{"type":"object"}');
+    writeFileSync(resolve(source, 'authors.schema.json'), '{"a":1}');
+
+    const outDir = resolve(tmpDir, 'dist');
+    mkdirSync(outDir, { recursive: true });
+
+    const integration = NebulaCMS();
+    const hook = integration.hooks['astro:build:done'] as Function;
+    hook({ dir: pathToFileURL(outDir + '/'), logger });
+
+    const target = resolve(outDir, 'collections');
+    expect(existsSync(resolve(target, 'posts.schema.json'))).toBe(true);
+    expect(existsSync(resolve(target, 'authors.schema.json'))).toBe(true);
+    expect(readFileSync(resolve(target, 'posts.schema.json'), 'utf-8')).toBe(
+      '{"type":"object"}',
+    );
+  });
+
+  it('warns when .astro/collections does not exist', () => {
+    const outDir = resolve(tmpDir, 'dist');
+    mkdirSync(outDir, { recursive: true });
+
+    const integration = NebulaCMS();
+    const hook = integration.hooks['astro:build:done'] as Function;
+    hook({ dir: pathToFileURL(outDir + '/'), logger });
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('.astro/collections'),
+    );
+  });
+
+  it('uses custom collectionsPath for the output directory', () => {
+    const source = resolve(tmpDir, '.astro/collections');
+    mkdirSync(source, { recursive: true });
+    writeFileSync(resolve(source, 'posts.schema.json'), '{}');
+
+    const outDir = resolve(tmpDir, 'dist');
+    mkdirSync(outDir, { recursive: true });
+
+    const integration = NebulaCMS({ collectionsPath: '/schemas' });
+    const hook = integration.hooks['astro:build:done'] as Function;
+    hook({ dir: pathToFileURL(outDir + '/'), logger });
+
+    expect(existsSync(resolve(outDir, 'schemas/posts.schema.json'))).toBe(true);
+    expect(existsSync(resolve(outDir, 'collections'))).toBe(false);
+  });
+});
+
+/*
+//////////////////////////////
+// load hook
+//////////////////////////////
+*/
+
+describe('nebulaVitePlugin load', () => {
+  let tmpDir: string;
+  let logger: AstroIntegrationLogger;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'nebula-test-'));
+    logger = createMockLogger();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns undefined for unrelated module IDs', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    expect(plugin.load('some-other-id')).toBeUndefined();
+  });
+
+  it('generates config module with basePath and collectionsPath', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/dashboard',
+      collectionsPath: '/schemas',
+    });
+    const result = plugin.load('\0virtual:nebula/config');
+
+    expect(result).toContain('"/dashboard"');
+    expect(result).toContain('"/schemas"');
+    expect(result).toContain('export default');
+  });
+
+  it('generates collections module mapping names to schema URLs', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toContain('"posts"');
+    expect(result).toContain('"/collections/posts.schema.json"');
+  });
+
+  it('handles multiple schema files', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+    writeFileSync(resolve(dir, 'authors.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toContain('"posts"');
+    expect(result).toContain('"authors"');
+  });
+
+  it('ignores non-.schema.json files in the directory', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+    writeFileSync(resolve(dir, 'README.md'), '');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toContain('"posts"');
+    expect(result).not.toContain('README');
+  });
+
+  it('strips .schema.json suffix for collection names', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'my-collection.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toContain('"my-collection"');
+    expect(result).not.toContain('.schema.json":');
+  });
+
+  it('returns empty default export and warns when directory is missing', () => {
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/collections',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toBe('export default {};');
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('.astro/collections'),
+    );
+  });
+
+  it('generates URLs with custom collectionsPath prefix', () => {
+    const dir = resolve(tmpDir, '.astro/collections');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, 'posts.schema.json'), '{}');
+
+    const plugin = nebulaVitePlugin(logger, tmpDir, {
+      basePath: '/admin',
+      collectionsPath: '/schemas',
+    });
+    const result = plugin.load('\0virtual:nebula/collections');
+
+    expect(result).toContain('"posts"');
+    expect(result).toContain('"/schemas/posts.schema.json"');
+    expect(result).not.toContain('/collections/');
+  });
+});