@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/packages/frontend/src/api/client_files.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ApiClient } from './client.ts';
+
+describe('ApiClient file CRUD methods', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it('createFile sends POST with path and type', async () => {
+    let capturedUrl: string | undefined;
+    let capturedMethod: string | undefined;
+    let capturedBody: string | undefined;
+
+    globalThis.fetch = mock.fn(async (url: any, init?: any) => {
+      capturedUrl = url;
+      capturedMethod = init?.method;
+      capturedBody = init?.body;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ success: true }),
+      };
+    }) as any;
+
+    const client = new ApiClient();
+    const result = await client.createFile('proj_001', 'src/new_file.ts', 'file');
+
+    assert.ok(capturedUrl!.includes('/api/projects/proj_001/files'));
+    assert.equal(capturedMethod, 'POST');
+    const body = JSON.parse(capturedBody!);
+    assert.equal(body.path, 'src/new_file.ts');
+    assert.equal(body.type, 'file');
+    assert.equal(result.success, true);
+  });
+
+  it('createFile sends directory type', async () => {
+    let capturedBody: string | undefined;
+
+    globalThis.fetch = mock.fn(async (_url: any, init?: any) => {
+      capturedBody = init?.body;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ success: true }),
+      };
+    }) as any;
+
+    const client = new ApiClient();
+    await client.createFile('proj_001', 'src/utils', 'directory');
+
+    const body = JSON.parse(capturedBody!);
+    assert.equal(body.path, 'src/utils');
+    assert.equal(body.type, 'directory');
+  });
+
+  it('createFile throws on error', async () => {
+    globalThis.fetch = mock.fn(async () => ({
+      ok: false,
+      status: 400,
+      json: async () => ({ error: 'Path already exists' }),
+    })) as any;
+
+    const client = new ApiClient();
+    await assert.rejects(
+      () => client.createFile('proj_001', 'existing.ts', 'file'),
+      { message: 'Path already exists' },
+    );
+  });
+
+  it('deleteFile sends DELETE with path as query param', async () => {
+    let capturedUrl: string | undefined;
+    let capturedMethod: string | undefined;
+
+    globalThis.fetch = mock.fn(async (url: any, init?: any) => {
+      capturedUrl = url;
+      capturedMethod = init?.method;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ success: true }),
+      };
+    }) as any;
+
+    const client = new ApiClient();
+    await client.deleteFile('proj_001', 'src/old.ts');
+
+    assert.ok(capturedUrl!.includes('/api/projects/proj_001/files?path='));
+    assert.ok(capturedUrl!.includes(encodeURIComponent('src/old.ts')));
+    assert.equal(capturedMethod, 'DELETE');
+  });
+
+  it('deleteFile throws on error', async () => {
+    globalThis.fetch = mock.fn(async () => ({
+      ok: false,
+      status: 404,
+      json: async () => ({ error: 'File not found' }),
+    })) as any;
+
+    const client = new ApiClient();
+    await assert.rejects(
+      () => client.deleteFile('proj_001', 'nonexistent.ts'),
+      { message: 'File not found' },
+    );
+  });
+
+  it('renameFile sends PATCH with oldPath and newPath', async () => {
+    let capturedUrl: string | undefined;
+    let capturedMethod: string | undefined;
+    let capturedBody: string | undefined;
+
+    globalThis.fetch = mock.fn(async (url: any, init?: any) => {
+      capturedUrl = url;
+      capturedMethod = init?.method;
+      capturedBody = init?.body;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ success: true }),
+      };
+    }) as any;
+
+    const client = new ApiClient();
+    await client.renameFile('proj_001', 'src/old.ts', 'src/new.ts');
+
+    assert.ok(capturedUrl!.includes('/api/projects/proj_001/files'));
+    assert.equal(capturedMethod, 'PATCH');
+    const body = JSON.parse(capturedBody!);
+    assert.equal(body.oldPath, 'src/old.ts');
+    assert.equal(body.newPath, 'src/new.ts');
+  });
+
+  it('renameFile throws on error', async () => {
+    globalThis.fetch = mock.fn(async () => ({
+      ok: false,
+      status: 400,
+      json: async () => ({ error: 'Invalid path' }),
+    })) as any;
+
+    const client = new ApiClient();
+    await assert.rejects(
+      () => client.renameFile('proj_001', '../escape', 'new.ts'),
+      { message: 'Invalid path' },
+    );
+  });
+
+  it('fetchFileTree sends GET to files endpoint', async () => {
+    let capturedUrl: string | undefined;
+
+    const treeData = { tree: [{ name: 'src', path: 'src', type: 'directory', children: [] }] };
+    globalThis.fetch = mock.fn(async (url: any) => {
+      capturedUrl = url;
+      return {
+        ok: true,
+        status: 200,
+        json: async () => treeData,
+      };
+    }) as any;
+
+    const client = new ApiClient();
+    const result = await client.fetchFileTree('proj_001');
+
+    assert.ok(capturedUrl!.includes('/api/projects/proj_001/files'));
+    assert.deepEqual(result.tree, treeData.tree);
+  });
+});

package/templates/assistkick-product-system/packages/frontend/src/api/client_video.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { ApiClient } from './client.ts';
+
+describe('ApiClient video methods', () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  describe('fetchVideoCompositions', () => {
+    it('returns compositions list from the API', async () => {
+      const compositions = [
+        { id: 'my-video', durationInFrames: 300, fps: 30, width: 1920, height: 1080 },
+        { id: 'intro', durationInFrames: 150, fps: 24, width: 1280, height: 720, folder: 'Intros' },
+      ];
+
+      globalThis.fetch = mock.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => ({ compositions }),
+      })) as any;
+
+      const client = new ApiClient();
+      const result = await client.fetchVideoCompositions();
+      assert.deepEqual(result.compositions, compositions);
+    });
+
+    it('throws on non-OK response', async () => {
+      globalThis.fetch = mock.fn(async () => ({
+        ok: false,
+        status: 500,
+      })) as any;
+
+      const client = new ApiClient();
+      await assert.rejects(
+        () => client.fetchVideoCompositions(),
+        { message: /Failed to fetch video compositions: 500/ },
+      );
+    });
+  });
+
+  describe('fetchVideoBundleStatus', () => {
+    it('returns bundle status', async () => {
+      const status = {
+        ready: true,
+        building: false,
+        bundlePath: '/data/remotion-bundle',
+        lastBuiltAt: '2026-03-10T12:00:00Z',
+        error: null,
+      };
+
+      globalThis.fetch = mock.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => status,
+      })) as any;
+
+      const client = new ApiClient();
+      const result = await client.fetchVideoBundleStatus();
+      assert.deepEqual(result, status);
+    });
+
+    it('returns not-ready status when no bundle exists', async () => {
+      const status = {
+        ready: false,
+        building: false,
+        bundlePath: null,
+        lastBuiltAt: null,
+        error: null,
+      };
+
+      globalThis.fetch = mock.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => status,
+      })) as any;
+
+      const client = new ApiClient();
+      const result = await client.fetchVideoBundleStatus();
+      assert.equal(result.ready, false);
+      assert.equal(result.bundlePath, null);
+    });
+  });
+
+  describe('rebuildVideoBundle', () => {
+    it('triggers rebuild and returns new status', async () => {
+      const status = {
+        ready: false,
+        building: true,
+        bundlePath: null,
+        lastBuiltAt: null,
+        error: null,
+      };
+
+      let capturedMethod: string | undefined;
+      globalThis.fetch = mock.fn(async (_url: any, init?: any) => {
+        capturedMethod = init?.method;
+        return {
+          ok: true,
+          status: 200,
+          json: async () => status,
+        };
+      }) as any;
+
+      const client = new ApiClient();
+      const result = await client.rebuildVideoBundle();
+      assert.equal(capturedMethod, 'POST');
+      assert.equal(result.building, true);
+    });
+
+    it('throws on rebuild failure', async () => {
+      globalThis.fetch = mock.fn(async () => ({
+        ok: false,
+        status: 500,
+        json: async () => ({ error: 'Remotion bundle failed' }),
+      })) as any;
+
+      const client = new ApiClient();
+      await assert.rejects(
+        () => client.rebuildVideoBundle(),
+        { message: /Remotion bundle failed/ },
+      );
+    });
+  });
+
+  describe('fetchVideoRenders', () => {
+    it('returns renders list for a project', async () => {
+      const renders = [
+        {
+          id: 'r1', status: 'complete', progress: 100, compositionId: 'comp1',
+          filePath: '/data/r1.mp4', fileSize: 1024, durationSeconds: 10.5,
+          error: null, resolution: '1920x1080',
+          createdAt: '2026-03-10T10:00:00Z', completedAt: '2026-03-10T10:05:00Z',
+        },
+      ];
+
+      let capturedUrl: string = '';
+      globalThis.fetch = mock.fn(async (url: any) => {
+        capturedUrl = typeof url === 'string' ? url : url.toString();
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ renders }),
+        };
+      }) as any;
+
+      const client = new ApiClient();
+      const result = await client.fetchVideoRenders('proj_123');
+      assert.deepEqual(result.renders, renders);
+      assert.ok(capturedUrl.includes('projectId=proj_123'));
+    });
+
+    it('throws on non-OK response', async () => {
+      globalThis.fetch = mock.fn(async () => ({
+        ok: false,
+        status: 500,
+      })) as any;
+
+      const client = new ApiClient();
+      await assert.rejects(
+        () => client.fetchVideoRenders('proj_123'),
+        { message: /Failed to fetch video renders: 500/ },
+      );
+    });
+  });
+
+  describe('fetchVideoRenderStatus', () => {
+    it('returns render status by id', async () => {
+      const render = {
+        id: 'r1', status: 'rendering', progress: 45, compositionId: 'comp1',
+        filePath: null, fileSize: null, durationSeconds: null,
+        error: null, resolution: '1920x1080',
+        createdAt: '2026-03-10T10:00:00Z', completedAt: null,
+      };
+
+      globalThis.fetch = mock.fn(async () => ({
+        ok: true,
+        status: 200,
+        json: async () => render,
+      })) as any;
+
+      const client = new ApiClient();
+      const result = await client.fetchVideoRenderStatus('r1');
+      assert.equal(result.id, 'r1');
+      assert.equal(result.status, 'rendering');
+      assert.equal(result.progress, 45);
+    });
+  });
+
+  describe('deleteVideoRender', () => {
+    it('sends DELETE request', async () => {
+      let capturedMethod: string | undefined;
+      let capturedUrl: string = '';
+      globalThis.fetch = mock.fn(async (url: any, init?: any) => {
+        capturedMethod = init?.method;
+        capturedUrl = typeof url === 'string' ? url : url.toString();
+        return {
+          ok: true,
+          status: 200,
+          json: async () => ({ ok: true }),
+        };
+      }) as any;
+
+      const client = new ApiClient();
+      await client.deleteVideoRender('r1');
+      assert.equal(capturedMethod, 'DELETE');
+      assert.ok(capturedUrl.includes('/api/video/render/r1'));
+    });
+
+    it('throws on delete failure', async () => {
+      globalThis.fetch = mock.fn(async () => ({
+        ok: false,
+        status: 404,
+        json: async () => ({ error: 'Render not found' }),
+      })) as any;
+
+      const client = new ApiClient();
+      await assert.rejects(
+        () => client.deleteVideoRender('r1'),
+        { message: /Render not found/ },
+      );
+    });
+  });
+
+  describe('getVideoFileUrl', () => {
+    it('returns correct URL for render file', () => {
+      const client = new ApiClient();
+      const url = client.getVideoFileUrl('r1');
+      assert.ok(url.endsWith('/api/video/file/r1'));
+    });
+  });
+});