zephyr-astro-integration 0.0.0-canary.7 → 0.0.0-canary.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zephyr-astro-integration",
-  "version": "0.0.0-canary.7",
+  "version": "0.0.0-canary.8",
   "description": "Astro integration for Zephyr",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
   "types": "dist/index.d.ts",
   "dependencies": {
     "is-ci": "^4.1.0",
-    "zephyr-agent": "0.0.0-canary.7"
+    "zephyr-agent": "0.0.0-canary.8"
   },
   "devDependencies": {
     "@types/jest": "29.5.14",

package/.eslintrc.json

@@ -1,20 +0,0 @@
-{
-  "extends": ["../../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {
-        "no-empty": "off"
-      }
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    }
-  ]
-}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"version":"5.8.3"}

package/jest.config.ts

@@ -1,11 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'zephyr-astro-integration',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/libs/zephyr-astro-integration',
-};

package/project.json

@@ -1,37 +0,0 @@
-{
-  "name": "zephyr-astro-integration",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/zephyr-astro-integration/src",
-  "projectType": "library",
-  "tags": [],
-  "targets": {
-    "build": {
-      "executor": "@nx/js:tsc",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "rootDir": "libs/zephyr-astro-integration/src",
-        "outputPath": "libs/zephyr-astro-integration/dist",
-        "tsConfig": "libs/zephyr-astro-integration/tsconfig.lib.json",
-        "main": "libs/zephyr-astro-integration/src/index.ts"
-      }
-    },
-    "nx-release-publish": {
-      "options": {
-        "packageRoot": "dist\\{projectRoot}"
-      }
-    },
-    "release": {
-      "command": "pnpm dist-tag add zephyr-astro-integration@$(npm view zephyr-astro-integration@next version) latest"
-    },
-    "lint": {
-      "executor": "@nx/eslint:lint"
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "libs/zephyr-astro-integration/jest.config.ts"
-      }
-    }
-  }
-}

package/src/__test__/integration.spec.ts

@@ -1,19 +0,0 @@
-import { withZephyr } from '../index';
-
-describe('Integration Export', () => {
-  it('should export withZephyr function', () => {
-    expect(typeof withZephyr).toBe('function');
-  });
-
-  it('should create a valid Astro integration', () => {
-    const integration = withZephyr();
-
-    expect(integration).toMatchObject({
-      name: 'with-zephyr',
-      hooks: expect.objectContaining({
-        'astro:config:done': expect.any(Function),
-        'astro:build:done': expect.any(Function),
-      }),
-    });
-  });
-});

package/src/index.ts

@@ -1,2 +0,0 @@
-export { withZephyr } from './lib/astro-integration-zephyr';
-export { withZephyr as default } from './lib/astro-integration-zephyr';

package/src/lib/__test__/astro-integration-zephyr.spec.ts

@@ -1,242 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { logFn, zeBuildDashData, ZephyrEngine, ZephyrError } from 'zephyr-agent';
-import { withZephyr } from '../astro-integration-zephyr';
-import {
-  extractAstroAssetsFromBuildHook,
-  extractAstroAssetsMap,
-} from '../internal/extract-astro-assets-map';
-
-// Mock dependencies
-jest.mock('zephyr-agent', () => ({
-  ZephyrEngine: {
-    defer_create: jest.fn(),
-  },
-  logFn: jest.fn(),
-  ZephyrError: {
-    format: jest.fn(),
-  },
-  zeBuildDashData: jest.fn(),
-}));
-
-jest.mock('node:url', () => ({
-  fileURLToPath: jest.fn(),
-}));
-
-jest.mock('../internal/extract-astro-assets-map', () => ({
-  extractAstroAssetsFromBuildHook: jest.fn(),
-  extractAstroAssetsMap: jest.fn(),
-}));
-
-interface MockZephyrEngine {
-  buildProperties: { output: string };
-  start_new_build: jest.Mock;
-  upload_assets: jest.Mock;
-  build_finished: jest.Mock;
-}
-
-describe('withZephyr', () => {
-  let mockZephyrEngine: MockZephyrEngine;
-  let mockZephyrDefer: Promise<MockZephyrEngine>;
-  let mockZephyrDeferCreate: jest.Mock;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Mock ZephyrEngine setup
-    mockZephyrEngine = {
-      buildProperties: { output: '' },
-      start_new_build: jest.fn(),
-      upload_assets: jest.fn(),
-      build_finished: jest.fn(),
-    };
-
-    mockZephyrDefer = Promise.resolve(mockZephyrEngine);
-
-    mockZephyrDeferCreate = jest.fn();
-
-    const mockDeferCreate = jest.fn().mockReturnValue({
-      zephyr_engine_defer: mockZephyrDefer,
-      zephyr_defer_create: mockZephyrDeferCreate,
-    });
-
-    (ZephyrEngine.defer_create as jest.Mock).mockImplementation(mockDeferCreate);
-
-    (fileURLToPath as jest.Mock).mockImplementation((url: URL) => url.pathname);
-    (extractAstroAssetsFromBuildHook as jest.Mock).mockResolvedValue({});
-    (extractAstroAssetsMap as jest.Mock).mockResolvedValue({});
-    (ZephyrError.format as jest.Mock).mockImplementation((error: Error) => error.message);
-  });
-
-  describe('Basic Integration Structure', () => {
-    it('should return an Astro integration object', () => {
-      const integration = withZephyr();
-
-      expect(integration).toHaveProperty('name', 'with-zephyr');
-      expect(integration).toHaveProperty('hooks');
-      expect(integration.hooks).toHaveProperty('astro:config:done');
-      expect(integration.hooks).toHaveProperty('astro:build:done');
-    });
-
-    it('should accept options parameter', () => {
-      const integration = withZephyr();
-
-      expect(integration).toHaveProperty('name', 'with-zephyr');
-    });
-
-    it('should have the correct hook functions', () => {
-      const integration = withZephyr();
-
-      expect(typeof integration.hooks['astro:config:done']).toBe('function');
-      expect(typeof integration.hooks['astro:build:done']).toBe('function');
-    });
-  });
-
-  describe('astro:config:done hook', () => {
-    it('should initialize ZephyrEngine with correct context from config.root', async () => {
-      const integration = withZephyr();
-
-      const mockConfig = {
-        root: new URL('file:///test/project/'),
-      };
-
-      await integration.hooks['astro:config:done']?.({
-        config: mockConfig,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:config:done']>>[0]);
-
-      expect(fileURLToPath).toHaveBeenCalledWith(mockConfig.root);
-      expect(mockZephyrDeferCreate).toHaveBeenCalledWith({
-        builder: 'astro',
-        context: '/test/project/',
-      });
-    });
-
-    it('should handle errors during setup', async () => {
-      const testError = new Error('Setup failed');
-      mockZephyrDeferCreate.mockImplementation(() => {
-        throw testError;
-      });
-
-      const integration = withZephyr();
-      const mockConfig = { root: new URL('file:///test/project/') };
-
-      await integration.hooks['astro:config:done']?.({
-        config: mockConfig,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:config:done']>>[0]);
-
-      expect(ZephyrError.format).toHaveBeenCalledWith(testError);
-      expect(logFn).toHaveBeenCalledWith('error', 'Setup failed');
-    });
-  });
-
-  describe('astro:build:done hook', () => {
-    it('should complete the full build workflow with assets parameter', async () => {
-      const integration = withZephyr();
-      const mockDir = new URL('file:///test/dist/');
-      const mockAssets = { 'index.html': '/test/dist/index.html' };
-      const mockAssetsMap = { hash1: { content: 'test', type: 'text/html' } };
-      const mockBuildStats = { stats: 'test' };
-
-      (extractAstroAssetsFromBuildHook as jest.Mock).mockResolvedValue(mockAssetsMap);
-      (zeBuildDashData as jest.Mock).mockResolvedValue(mockBuildStats);
-
-      await integration.hooks['astro:build:done']?.({
-        dir: mockDir,
-        assets: mockAssets,
-      } as unknown as Parameters<
-        NonNullable<(typeof integration.hooks)['astro:build:done']>
-      >[0]);
-
-      expect(fileURLToPath).toHaveBeenCalledWith(mockDir);
-      expect(mockZephyrEngine.buildProperties.output).toBe('/test/dist/');
-      expect(mockZephyrEngine.start_new_build).toHaveBeenCalled();
-      expect(extractAstroAssetsFromBuildHook).toHaveBeenCalledWith(
-        mockAssets,
-        '/test/dist/'
-      );
-      expect(mockZephyrEngine.upload_assets).toHaveBeenCalledWith({
-        assetsMap: mockAssetsMap,
-        buildStats: mockBuildStats,
-      });
-      expect(mockZephyrEngine.build_finished).toHaveBeenCalled();
-    });
-
-    it('should handle missing assets parameter gracefully', async () => {
-      const integration = withZephyr();
-      const mockDir = new URL('file:///test/dist/');
-      const mockAssetsMap = { hash1: { content: 'test', type: 'text/html' } };
-      const mockBuildStats = { stats: 'test' };
-
-      (extractAstroAssetsFromBuildHook as jest.Mock).mockResolvedValue(mockAssetsMap);
-      (zeBuildDashData as jest.Mock).mockResolvedValue(mockBuildStats);
-
-      // Call without assets parameter
-      await integration.hooks['astro:build:done']?.({
-        dir: mockDir,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:build:done']>>[0]);
-
-      expect(extractAstroAssetsFromBuildHook).toHaveBeenCalledWith(
-        undefined,
-        '/test/dist/'
-      );
-      expect(mockZephyrEngine.upload_assets).toHaveBeenCalled();
-    });
-
-    it('should handle errors during build completion', async () => {
-      const integration = withZephyr();
-      const mockDir = new URL('file:///test/dist/');
-      const mockAssets = { 'index.html': '/test/dist/index.html' };
-      const testError = new Error('Build failed');
-
-      (extractAstroAssetsFromBuildHook as jest.Mock).mockRejectedValue(testError);
-
-      await integration.hooks['astro:build:done']?.({
-        dir: mockDir,
-        assets: mockAssets,
-      } as unknown as Parameters<
-        NonNullable<(typeof integration.hooks)['astro:build:done']>
-      >[0]);
-
-      expect(ZephyrError.format).toHaveBeenCalledWith(testError);
-      expect(logFn).toHaveBeenCalledWith('error', 'Build failed');
-    });
-
-    it('should handle engine initialization errors', async () => {
-      const badEngine = Promise.reject(new Error('Engine failed'));
-      (ZephyrEngine.defer_create as jest.Mock).mockReturnValue({
-        zephyr_engine_defer: badEngine,
-        zephyr_defer_create: jest.fn(),
-      });
-
-      const integration = withZephyr();
-      const mockDir = new URL('file:///test/dist/');
-
-      await integration.hooks['astro:build:done']?.({
-        dir: mockDir,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:build:done']>>[0]);
-
-      expect(ZephyrError.format).toHaveBeenCalledWith(new Error('Engine failed'));
-      expect(logFn).toHaveBeenCalledWith('error', 'Engine failed');
-    });
-  });
-
-  describe('Integration Lifecycle', () => {
-    it('should handle sequential hook calls correctly', async () => {
-      const integration = withZephyr();
-
-      // First call config:done
-      const mockConfig = { root: new URL('file:///test/project/') };
-      await integration.hooks['astro:config:done']?.({
-        config: mockConfig,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:config:done']>>[0]);
-
-      // Then call build:done
-      const mockDir = new URL('file:///test/dist/');
-      await integration.hooks['astro:build:done']?.({
-        dir: mockDir,
-      } as Parameters<NonNullable<(typeof integration.hooks)['astro:build:done']>>[0]);
-
-      expect(mockZephyrEngine.start_new_build).toHaveBeenCalled();
-      expect(mockZephyrEngine.build_finished).toHaveBeenCalled();
-    });
-  });
-});

package/src/lib/astro-integration-zephyr.ts

@@ -1,63 +0,0 @@
-import type { AstroIntegration, HookParameters } from 'astro';
-import { fileURLToPath } from 'node:url';
-import { logFn, zeBuildDashData, ZephyrEngine, ZephyrError } from 'zephyr-agent';
-import { extractAstroAssetsFromBuildHook } from './internal/extract-astro-assets-map';
-
-type AstroBuildDoneParams = HookParameters<'astro:build:done'> & {
-  assets?: Record<string, unknown> | Map<string, unknown> | Array<unknown>;
-};
-
-export function withZephyr(): AstroIntegration {
-  const { zephyr_engine_defer, zephyr_defer_create } = ZephyrEngine.defer_create();
-
-  return {
-    name: 'with-zephyr',
-    hooks: {
-      'astro:config:done': async ({ config }: HookParameters<'astro:config:done'>) => {
-        // config.root is a URL object, convert to file path
-        const contextPath = fileURLToPath(config.root);
-        try {
-          // Initialize ZephyrEngine with Astro context
-          zephyr_defer_create({
-            builder: 'astro',
-            context: contextPath,
-          });
-        } catch (error) {
-          logFn('error', ZephyrError.format(error));
-        }
-      },
-      'astro:build:done': async ({
-        dir,
-        ...params
-      }: HookParameters<'astro:build:done'>) => {
-        try {
-          const zephyr_engine = await zephyr_engine_defer;
-
-          // Convert URL to file system path
-          const outputPath = fileURLToPath(dir);
-
-          // Set output directory for ZephyrEngine
-          zephyr_engine.buildProperties.output = outputPath;
-
-          // Start a new build
-          await zephyr_engine.start_new_build();
-
-          // Extract assets from params if available (Astro v5+), fallback to filesystem walking
-          const assets = (params as AstroBuildDoneParams).assets;
-          const assetsMap = await extractAstroAssetsFromBuildHook(assets, outputPath);
-
-          // Upload assets and build stats
-          await zephyr_engine.upload_assets({
-            assetsMap,
-            buildStats: await zeBuildDashData(zephyr_engine),
-          });
-
-          // Mark build as finished
-          await zephyr_engine.build_finished();
-        } catch (error) {
-          logFn('error', ZephyrError.format(error));
-        }
-      },
-    },
-  };
-}

package/src/lib/internal/__test__/extract-astro-assets-from-build-hook.spec.ts

@@ -1,269 +0,0 @@
-import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildAssetsMap } from 'zephyr-agent';
-import { extractAstroAssetsFromBuildHook } from '../extract-astro-assets-map';
-
-// Mock the zephyr-agent buildAssetsMap function
-jest.mock('zephyr-agent', () => ({
-  buildAssetsMap: jest.fn(),
-  logFn: jest.fn(),
-}));
-
-// This test focuses on the assets parameter parsing logic
-// Fallback behavior is tested in the integration tests
-
-describe('extractAstroAssetsFromBuildHook', () => {
-  let tempDir: string;
-  let consoleSpy: jest.SpyInstance;
-
-  beforeEach(async () => {
-    tempDir = join(tmpdir(), `astro-assets-hook-test-${Date.now()}`);
-    await mkdir(tempDir, { recursive: true });
-    consoleSpy = jest.spyOn(console, 'warn').mockImplementation(() => {
-      // Mock implementation
-    });
-
-    // Mock buildAssetsMap to return a simple hash-based result
-    (buildAssetsMap as jest.Mock).mockImplementation((assets) => {
-      const result: Record<string, unknown> = {};
-      Object.keys(assets).forEach((key, index) => {
-        const hash = `hash${index + 1}`;
-        result[hash] = {
-          hash,
-          content: assets[key].content,
-          type: assets[key].type,
-          filepath: key,
-        };
-      });
-      return result;
-    });
-
-    // No need to mock fallback for core functionality tests
-  });
-
-  afterEach(async () => {
-    try {
-      await rm(tempDir, { recursive: true, force: true });
-    } catch {
-      // Ignore cleanup errors
-    }
-    if (consoleSpy && typeof consoleSpy.mockRestore === 'function') {
-      consoleSpy.mockRestore();
-    }
-    jest.clearAllMocks();
-  });
-
-  describe('Assets Parameter Handling', () => {
-    it('should handle assets as a plain object with file paths', async () => {
-      // Create test files
-      await writeFile(join(tempDir, 'index.html'), '<html><body>Hello</body></html>');
-      await writeFile(join(tempDir, 'style.css'), 'body { color: red; }');
-
-      const assets = {
-        'index.html': join(tempDir, 'index.html'),
-        'style.css': join(tempDir, 'style.css'),
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.objectContaining({
-            content: expect.any(Buffer),
-            type: 'text/html',
-          }),
-          'style.css': expect.objectContaining({
-            content: expect.any(Buffer),
-            type: 'text/css',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle assets as a Map', async () => {
-      // Create test files
-      await writeFile(join(tempDir, 'script.js'), 'console.log("hello");');
-
-      const assets = new Map([['script.js', join(tempDir, 'script.js')]]);
-
-      const result = await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(result).toBeDefined();
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'script.js': expect.objectContaining({
-            type: 'application/javascript',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle assets as an array of strings', async () => {
-      // Create test files
-      await writeFile(join(tempDir, 'data.json'), '{"key": "value"}');
-
-      const assets = [join(tempDir, 'data.json')];
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'data.json': expect.objectContaining({
-            type: 'application/json',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle assets as an array of objects with path properties', async () => {
-      // Create test files
-      await writeFile(join(tempDir, 'image.png'), 'PNG data');
-
-      const assets = [{ path: join(tempDir, 'image.png'), size: 1024 }];
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'image.png': expect.objectContaining({
-            type: 'image/png',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle URL objects', async () => {
-      // Create test file
-      await writeFile(join(tempDir, 'favicon.ico'), 'ICO data');
-
-      const assets = {
-        'favicon.ico': new URL(`file://${join(tempDir, 'favicon.ico')}`),
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'favicon.ico': expect.objectContaining({
-            type: 'image/x-icon',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-
-  // Fallback behavior is tested in integration tests to avoid mocking complexity
-
-  describe('File Filtering', () => {
-    it('should skip files that match skip patterns', async () => {
-      // Create test files including ones that should be skipped
-      await writeFile(join(tempDir, 'index.html'), '<html></html>');
-      await writeFile(join(tempDir, 'style.css.map'), '{"version":3}');
-
-      const assets = {
-        'index.html': join(tempDir, 'index.html'),
-        'style.css.map': join(tempDir, 'style.css.map'),
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'index.html': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-
-      // Should not include the .map file
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.not.objectContaining({
-          'style.css.map': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-
-  describe('Error Handling', () => {
-    // File read error handling and fallback behavior is tested in integration tests
-
-    it('should handle complex nested asset structures', async () => {
-      // Create test file
-      await writeFile(join(tempDir, 'complex.json'), '{"nested": "data"}');
-
-      const assets = {
-        route1: [join(tempDir, 'complex.json'), { path: join(tempDir, 'complex.json') }],
-        route2: {
-          url: join(tempDir, 'complex.json'),
-        },
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'complex.json': expect.any(Object),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-
-  describe('Path Resolution', () => {
-    it('should handle relative paths correctly', async () => {
-      // Create test file
-      await writeFile(join(tempDir, 'relative.css'), 'body {}');
-
-      const assets = {
-        'relative.css': 'relative.css', // Relative path
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'relative.css': expect.objectContaining({
-            type: 'text/css',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-
-    it('should handle absolute paths correctly', async () => {
-      // Create test file
-      await writeFile(join(tempDir, 'absolute.js'), 'console.log()');
-
-      const assets = {
-        'absolute.js': join(tempDir, 'absolute.js'), // Absolute path
-      };
-
-      await extractAstroAssetsFromBuildHook(assets, tempDir);
-
-      expect(buildAssetsMap).toHaveBeenCalledWith(
-        expect.objectContaining({
-          'absolute.js': expect.objectContaining({
-            type: 'application/javascript',
-          }),
-        }),
-        expect.any(Function),
-        expect.any(Function)
-      );
-    });
-  });
-});