@grest-ts/create-starter 0.0.23 → 0.0.24

package/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { cpSync, readdirSync, renameSync, readFileSync, writeFileSync, statSync, existsSync } from "fs"
+import { cpSync, readdirSync, renameSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, statSync, existsSync } from "fs"
 import { join, dirname } from "path"
 import { fileURLToPath } from "url"
 import { createInterface } from "readline/promises"
@@ -79,6 +79,19 @@ async function main() {
     }
   }
 
+  // 4. Fan out project-context.md to all AI tool locations, then remove the source file.
+  //    Single source in template → CLAUDE.md, AGENTS.md, .cursor/rules/project.mdc in new project.
+  const projectContextSrc = join(targetDir, "project-context.md")
+  if (existsSync(projectContextSrc)) {
+    const body = readFileSync(projectContextSrc, "utf-8")
+    const mdcFrontmatter = `---\ndescription: grest-ts project context\nglobs: ["**/*.ts", "**/*.tsx"]\nalwaysApply: true\n---\n\n`
+    writeFileSync(join(targetDir, "CLAUDE.md"), body)
+    writeFileSync(join(targetDir, "AGENTS.md"), body)
+    mkdirSync(join(targetDir, ".cursor", "rules"), { recursive: true })
+    writeFileSync(join(targetDir, ".cursor", "rules", "project.mdc"), mdcFrontmatter + body)
+    unlinkSync(projectContextSrc)
+  }
+
   console.log(`  Done! Next steps:`)
   console.log()
   console.log(`    cd ${name}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grest-ts/create-starter",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "type": "module",
   "license": "MIT",
   "description": "Scaffold a new grest-ts project",

package/template/project-context.md

@@ -0,0 +1,25 @@
+# Project context
+
+This is a **grest-ts** project (npm workspaces monorepo).
+Framework docs: https://github.com/grest-ts/grest-ts
+
+## Package layout
+
+```
+api/      — shared API contracts (@newproject/api)
+            api/src/api/   ← contract definitions live here
+server/   — backend implementation + integration tests
+            server/src/AppRuntime.ts   ← runtime entry point (compose() wires everything)
+            server/src/services/       ← API implementations
+            server/test/integration/   ← integration tests
+            server/test/TestContext.ts ← extend GGTestContext here for auth helpers
+client/   — frontend
+```
+
+## Key conventions
+
+- Contracts defined in `api/` are imported by both `server/` and `client/`.
+- All service wiring is in `AppRuntime.compose()` — no DI, plain constructors.
+- Integration tests use `GGTest.startWorker(AppRuntime)` + `GGTestContext.apis()`.
+- Run server: `cd server && npm run dev`
+- Run tests: `cd server && npm test`

package/template/server/package.json

@@ -17,6 +17,7 @@
     "@grest-ts/runtime": "*",
     "@grest-ts/schema": "*",
     "@grest-ts/testkit": "*",
+    "@grest-ts/testkit-runtime": "*",
     "@grest-ts/testkit-vitest": "*",
     "@newproject/api": "*"
   },

package/template/server/src/AppRuntime.ts

@@ -4,6 +4,7 @@ import {GG_LOG} from "@grest-ts/logger"
 import {GGLoggerConsole} from "@grest-ts/logger-console"
 import {HelloApi} from "@newproject/api/api/HelloApi"
 import {HelloApiImpl} from "./services/HelloApiImpl"
+import {GreetingService} from "./services/GreetingService"
 
 export class AppRuntime extends GGRuntime {
 
@@ -14,8 +15,10 @@ export class AppRuntime extends GGRuntime {
 
         const httpServer = new GGHttpServer()
 
+        const greetingService = new GreetingService()
+
         new GGHttp(httpServer)
-            .http(HelloApi, new HelloApiImpl())
+            .http(HelloApi, new HelloApiImpl(greetingService))
     }
 }
 

package/template/server/src/services/GreetingService.ts

@@ -0,0 +1,8 @@
+import {mockable} from "@grest-ts/testkit-runtime"
+
+@mockable
+export class GreetingService {
+    async format(name: string): Promise<string> {
+        return `Hello, ${name}!`
+    }
+}

package/template/server/src/services/HelloApiImpl.ts

@@ -1,8 +1,11 @@
 import type {HelloRequest, HelloResponse} from "@newproject/api/api/HelloApi"
+import {GreetingService} from "./GreetingService"
 
 export class HelloApiImpl {
 
+    constructor(private readonly greetingService: GreetingService) {}
+
     public hello = async (input: HelloRequest): Promise<HelloResponse> => {
-        return {message: `Hello, ${input.name}!`}
+        return {message: await this.greetingService.format(input.name)}
     }
 }

package/template/server/test/integration/hello.test.ts

@@ -1,6 +1,7 @@
-import {GGTest} from "@grest-ts/testkit"
+import {GGTest, mockOf} from "@grest-ts/testkit"
 import {AppRuntime} from "../../src/AppRuntime"
 import {HelloApi} from "@newproject/api/api/HelloApi"
+import {GreetingService} from "../../src/services/GreetingService"
 import {TestContext} from "../TestContext"
 
 describe("Hello API", () => {
@@ -19,4 +20,13 @@ describe("Hello API", () => {
         await ctx.hello.hello({name: "Alice"})
             .toMatchObject({message: "Hello, Alice!"})
     })
+
+    test("hello uses GreetingService (mockable demo)", async () => {
+        await ctx.hello.hello({name: "World"})
+            .with(mockOf(GreetingService).format
+                .toEqual({name: "World"})
+                .andReturn("Mocked!")
+            )
+            .toMatchObject({message: "Mocked!"})
+    })
 })