@fougere/cli 0.2.0-alpha.1 → 0.3.0-alpha.0

package/templates/frond/AGENTS.md

@@ -0,0 +1,14 @@
+# Working in this application
+
+This project is built with **Fougere**. Read `CLAUDE.md` for the model and architecture guidance
+that applies to every coding agent.
+
+## Required verification workflow
+
+After every change to handlers, entities, Fronds, configuration, or topology:
+
+1. Run `fougere check`.
+2. Fix every deterministic error it reports before continuing.
+3. Run the relevant tests, then run `npx tsc -p fronds --noEmit`.
+
+`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/frond/CLAUDE.md

@@ -35,8 +35,8 @@ Before adding a surface, reach for its **projection**:
 
 | surface | the call |
 |---|---|
-| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/schema-rest` |
-| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/schema-graphql` |
+| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/adapter-rest` |
+| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/adapter-graphql` |
 
 Hand-writing the types (`buildSchema`, raw SDL, one Pothos resolver per field) rebuilds what the
 projection already derives, and drops the judge on the way. `registerType` / `registerOperations`
@@ -44,7 +44,18 @@ exist to add what a projection cannot derive — never to replace it.
 
 ## Reading data
 
-`EntityOrm`, injected by type, is the only data access:
+Storage is reached through a repository. Never inject `EntityOrm` directly into a handler,
+presenter or collector — the boot refuses it. With no repository file, ask for the default shape:
+
+```ts
+import type { RepositoryOf } from '@fougere/core';
+import Product from '../entities/Product.js';
+
+constructor(private products: RepositoryOf<Product>) {}
+```
+
+If the handler extends `Crud(Product)`, its inherited `this.orm` is already backed by that
+repository; do not add a constructor. The repository forwards the guarded storage gestures:
 
 ```
 list(options?)        every row — `options.where` filters, plus paging and sorting
@@ -56,10 +67,21 @@ create / update / delete
 
 Read a relation with `findAllBy`. Never read a whole table to filter it in memory.
 
+When a query deserves a domain name, add `repositories/ProductRepository.ts` with
+`class ProductRepository extends Repository(Product)`, put the query there, and inject
+`ProductRepository`. A repository is registered as a provider and remains the only route to storage.
+
 ## Checking your work
 
+After every change to handlers, entities, Fronds, configuration, or topology:
+
+1. Run `fougere check`.
+2. Fix every deterministic error it reports before continuing.
+3. Run the relevant tests, then run the project typecheck.
+
 ```bash
-npx tsc -p fronds --noEmit    # the compiler — free, immediate, and it catches most of it
+fougere check
+npx tsc -p fronds --noEmit
 ```
 
-Run it. It is the first judge, and the cheapest.
+`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/frond/fronds/__name__/handlers/PostHandler.ts

@@ -10,7 +10,7 @@ export default class PostHandler extends Crud(Post) {
     if (!post) {
       throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `Post '${id}' not found`, entity: 'post', operation: 'publish' });
     }
-    if ((post as { status?: string }).status === 'published') {
+    if (post.status === 'published') {
       throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already published', entity: 'post', operation: 'publish' });
     }
     return this.orm.update(id, { status: 'published' });
@@ -18,9 +18,7 @@ export default class PostHandler extends Crud(Post) {
 
   /** Only published posts, projected to the card. */
   async published(): Promise<PostCard[]> {
-    const all = await this.orm.list();
-    return all
-      .filter((p) => (p as { status?: string }).status === 'published')
-      .map((p) => ({ id: String(p.id), title: String(p.title), status: 'published' })) as PostCard[];
+    const posts = await this.orm.list({ where: { status: 'published' } });
+    return posts.map(({ id, title, status }) => ({ id, title, status }));
   }
 }

package/templates/frond/fronds/__name__/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/__name__",
+  "name": "@fronds/__name__",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/frond/package.json

@@ -8,7 +8,7 @@
   "dependencies": {
     "@fougere/core": "latest",
     "@fougere/schema": "latest",
-    "@fougere/runtime": "latest",
+    "@fougere/defaults": "latest",
     "@fougere/transport-http": "latest",
     "better-sqlite3": "^13.0.3",
     "kysely": "^0.28.17",

package/templates/frond/serve.mjs

@@ -8,11 +8,12 @@
  * Nothing in the frond changes — only where it runs.
  */
 import { createJiti } from 'jiti';
-import { createLocalRunner, setModuleLoader, frondAliases, Logger } from '@fougere/core';
-import { bootAppFromConfig } from '@fougere/runtime';
+import { createLocalRunner, Logger } from '@fougere/core';
+import { setModuleLoader, frondAliases } from '@fougere/core/node';
+import { bootAppFromConfig } from '@fougere/defaults';
 import { serve } from '@fougere/transport-http';
 
-// `frondAliases` is what makes `@frond/<neighbour>/entities/X.js` resolve — the
+// `frondAliases` is what makes `@fronds/<neighbour>/entities/X.js` resolve — the
 // named form a frond uses for its neighbour. A bare jiti loads frond sources but
 // not that convention, so a collector or handler importing across fronds dies here
 // while the same code works in-process.

package/templates/fronds/blank/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/__name__",
+  "name": "@fronds/__name__",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/fronds/blog/handlers/PostHandler.ts

@@ -30,9 +30,7 @@ export default class PostHandler extends Crud(Post) {
 
   /** Only published posts, projected to the card. */
   async published(): Promise<PostCard[]> {
-    const all = await this.orm.list();
-    return all
-      .filter((p) => p.status === 'published')
-      .map(({ id, title, status }) => ({ id, title, status }));
+    const posts = await this.orm.list({ where: { status: 'published' } });
+    return posts.map(({ id, title, status }) => ({ id, title, status }));
   }
 }

package/templates/fronds/blog/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/__name__",
+  "name": "@fronds/__name__",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/workspace/AGENTS.md

@@ -0,0 +1,14 @@
+# Working in this application
+
+This project is built with **Fougere**. Read `CLAUDE.md` for the model and architecture guidance
+that applies to every coding agent.
+
+## Required verification workflow
+
+After every change to handlers, entities, Fronds, configuration, or topology:
+
+1. Run `fougere check`.
+2. Fix every deterministic error it reports before continuing.
+3. Run the relevant tests, then run `pnpm typecheck`.
+
+`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/workspace/CLAUDE.md

@@ -35,8 +35,8 @@ Before adding a surface, reach for its **projection**:
 
 | surface | the call |
 |---|---|
-| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/schema-rest` |
-| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/schema-graphql` |
+| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/adapter-rest` |
+| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/adapter-graphql` |
 
 Hand-writing the types (`buildSchema`, raw SDL, one Pothos resolver per field) rebuilds what the
 projection already derives, and drops the judge on the way. `registerType` / `registerOperations`
@@ -44,7 +44,18 @@ exist to add what a projection cannot derive — never to replace it.
 
 ## Reading data
 
-`EntityOrm`, injected by type, is the only data access:
+Storage is reached through a repository. Never inject `EntityOrm` directly into a handler,
+presenter or collector — the boot refuses it. With no repository file, ask for the default shape:
+
+```ts
+import type { RepositoryOf } from '@fougere/core';
+import Product from '../entities/Product.js';
+
+constructor(private products: RepositoryOf<Product>) {}
+```
+
+If the handler extends `Crud(Product)`, its inherited `this.orm` is already backed by that
+repository; do not add a constructor. The repository forwards the guarded storage gestures:
 
 ```
 list(options?)        every row — `options.where` filters, plus paging and sorting
@@ -56,10 +67,21 @@ create / update / delete
 
 Read a relation with `findAllBy`. Never read a whole table to filter it in memory.
 
+When a query deserves a domain name, add `repositories/ProductRepository.ts` with
+`class ProductRepository extends Repository(Product)`, put the query there, and inject
+`ProductRepository`. A repository is registered as a provider and remains the only route to storage.
+
 ## Checking your work
 
+After every change to handlers, entities, Fronds, configuration, or topology:
+
+1. Run `fougere check`.
+2. Fix every deterministic error it reports before continuing.
+3. Run the relevant tests, then run the project typecheck.
+
 ```bash
-pnpm typecheck    # the compiler — free, immediate, and it catches most of it
+fougere check
+pnpm typecheck
 ```
 
-Run it. It is the first judge, and the cheapest.
+`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.