@cognite/dune 0.3.5 → 0.3.6

package/_templates/app/new/root/AGENTS.md.ejs.t

@@ -7,7 +7,8 @@ to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>AGENTS.md'
 
 Inject dependencies via React context (hooks/components) or factory-override pattern (plain functions). Never hard-code dependencies.
 
-**React context**
+### React context
+
 ```typescript
 const defaultDeps = { useDataSource, useAnalytics };
 export type MyHookContextType = typeof defaultDeps;
@@ -18,7 +19,8 @@ export function useMyHook() {
 }
 ```
 
-**Factory overrides**
+### Factory overrides
+
 ```typescript
 type Deps = { serviceFactory: () => SomeService };
 const defaultDeps: Deps = { serviceFactory: () => new SomeServiceImpl() };
@@ -40,7 +42,9 @@ export interface DataService {
   save(data: Data): Promise<void>;
 }
 
-export class ApiDataService implements DataService { /* ... */ }
+export class ApiDataService implements DataService {
+  /* ... */
+}
 ```
 
 ---
@@ -53,51 +57,89 @@ Business logic lives in `use<Name>ViewModel`. Components only render.
 export function useTodoViewModel(): TodoViewModel {
   const { useTodoStorage, addTodoCommand } = useContext(TodoViewModelContext);
   const storage = useTodoStorage();
-  const addTodo = useCallback((text: string) => addTodoCommand(text, storage), [storage, addTodoCommand]);
+  const addTodo = useCallback(
+    (text: string) => addTodoCommand(text, storage),
+    [storage, addTodoCommand]
+  );
   return { todos: storage.listAllTodos(), addTodo };
 }
 
 export const TodoView = () => {
   const { todos, addTodo } = useTodoViewModel();
-  return <ul>{todos.map(t => <TodoItem key={t.id} todo={t} onAdd={addTodo} />)}</ul>;
+  return <ul>{todos.map((t) => <TodoItem key={t.id} todo={t} onAdd={addTodo} />)}</ul>;
 };
 ```
 
 ---
 
-## 4. Test-Driven Development
+## 4. Test-First Development
+
+Write tests before implementation for all non-trivial behavior changes.
 
-### File creation order
-1. Integration tests
-2. Unit tests
+### Preferred order
+
+Start with behavior-focused tests so requirements are specified before implementation details:
+
+1. Integration tests (user-visible behavior)
+2. Unit tests (isolated module logic)
 3. Source files to make tests pass
 
+For bug fixes, start by adding a failing regression test that reproduces the issue.
+
+Every new module with logic (service, hook, component, utility) must include a corresponding `*.test.ts(x)` file in the same changeset.
+
+### Reasonable exceptions
+
+- Bootstrapping/entry files (for example `main.tsx`)
+- Generated code
+- Trivial pure-markup components with no logic or state
+
+### Test levels in this repo
+
+- **Integration test**: validates behavior across boundaries (for example component + view model + service contract), mocking only external systems such as network APIs.
+- **Unit test**: validates one module in isolation (service, hook, utility, or component behavior).
+
+### Minimum expected coverage by file type
+
+| File type | Required test cases |
+| --- | --- |
+| Service (`*Service.ts`) | Correct request construction; response parsing; error thrown on non-OK status |
+| ViewModel hook (`use*ViewModel.ts`) | Loading state; success state with correct derived values; error state |
+| Pure utility / helper | Every exported function and all meaningful branches |
+| View component | Renders expected content from props; loading/error/empty states where applicable |
+
 ### Conventions
-- Files: `*.test.ts(x)` — runner: **Vitest** (`pnpm test` to run all, `vitest run` within a package)
-- Structure: Arrange / Act / Assert (explicit comments when test > ~10 statements)
-- One behavior per test; helper functions at the bottom of the file
-- Prefer context injection over `vi.mock`; always add a comment when `vi.mock` is unavoidable
+
+- Files: `*.test.ts(x)`; runner: **Vitest** (`pnpm test` or `vitest run`)
+- Structure: Arrange / Act / Assert (add explicit comments for longer tests)
+- One behavior per test
+- Keep helper functions at the bottom of the file
+- Prefer dependency/context injection over `vi.mock`; add a short reason when `vi.mock` is unavoidable
 
 ### Type-safe mocks
+
 ```typescript
 // Preferred: vi.fn(() => ...) for consistent behavior
 mockContext = { useUserInfo: vi.fn(() => ({ data: mockUser, isFetched: true })) };
 
-// For per-test reconfiguration
+// Per-test reconfiguration
 mockContext = { useUserInfo: vi.fn() };
 vi.mocked(mockContext.useUserInfo).mockReturnValue({ data: undefined, isFetched: true });
 ```
 
-For full interface mocks, use `assert.fail` on methods the unit under test should never call — or better, use narrow interfaces that only expose what is needed.
+For full interface mocks, use `assert.fail` on methods the unit under test should never call, or preferably define a narrower interface.
 
 ```typescript
 mockStorage = {
   list: vi.fn(),
-  retrieve: vi.fn(() => { assert.fail('Not implemented'); }),
+  retrieve: vi.fn(() => {
+    assert.fail('Not implemented');
+  }),
 };
 ```
 
-### React hooks
+### React hook test pattern
+
 ```typescript
 describe(useMyHook.name, () => {
   let mockContext: MyContextType;
@@ -112,25 +154,29 @@ describe(useMyHook.name, () => {
 
   it('should ...', async () => {
     const { result } = renderHook(() => useMyHook(), { wrapper });
-
-    await act(async () => { await result.current.someAction(); });
-
+    await act(async () => {
+      await result.current.someAction();
+    });
     await waitFor(() => expect(result.current.isLoading).toBe(false));
   });
 });
 ```
 
-### Type rules
-- Never use `any` — prefer `unknown` or strong types
-- No `as unknown as T` casts; for partial mocks use `{ ...defaults, ...overrides } as T`
+### Shared mock data
+
+Place reusable factories in `src/__mocks__/`. Use `.test` TLD for fake URLs (RFC 2606).
+
+---
+
+## 5. TypeScript Rules
+
+- Never use `any`; prefer `unknown` or explicit strong types
+- Never use `as unknown as T`; for partial test doubles use `{ ...defaults, ...overrides } as T`
+- Use direct React type imports: `import type { ComponentType, ReactNode } from 'react'`
 
 ```typescript
 function createMockWindow(overrides: Partial<Window> = {}): Window {
   return { postMessage: vi.fn(), ...overrides } as Window;
 }
 ```
-
-- Use direct React type imports: `import type { ComponentType, ReactNode } from 'react'`
-
-### Shared mock data
-Place reusable factories in `src/__mocks__/`. Use `.test` TLD for fake URLs (RFC 2606).
+---

package/_templates/app/new/root/package.json.ejs.t

@@ -23,7 +23,7 @@ to: '<%= useCurrentDir ? "" : ((directoryName || name) + "/") %>package.json'
   "dependencies": {
     "@cognite/aura": "^0.1.4",
     "@cognite/sdk": "^10.3.0",
-    "@cognite/dune": "^0.3.5",
+    "@cognite/dune": "^0.3.6",
     "@tabler/icons-react": "^3.35.0",
     "@tanstack/react-query": "^5.90.10",
     "clsx": "^2.1.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cognite/dune",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "Build and deploy React apps to Cognite Data Fusion",
   "keywords": ["cognite", "dune", "cdf", "fusion", "react", "scaffold", "deploy"],
   "license": "Apache-2.0",