@stratify/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Jean Michelet <jean.antoine.michelet@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+
+# Stratify CLI
+
+Command-line tool for [Stratify](https://www.npmjs.com/package/@stratify/core), a modular Fastify framework with DI and TypeScript support.
+It scaffolds a ready-to-use Stratify project with TypeScript, ESLint, and Prettier.
+
+## Installation
+
+```bash
+npm install -g @stratify/cli
+```
+
+## Usage
+
+```bash
+npx stratify-cli new <app-name>
+```
+
+Creates a new project with:
+
+* TypeScript + ESM
+* ESLint and Prettier setup
+* Example module under `/src/tasks` (controllers, providers, hooks, installers, adapters)
+
+Then:
+
+```bash
+cd <app-name>
+npm install
+npm run dev
+```

package/dist/bin.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { resolve } from "node:path";
+import { runNew } from "./new.js";
+async function main() {
+    const [cmd, name] = process.argv.slice(2);
+    if (!cmd || cmd !== "new") {
+        console.error(`Usage:
+  npx stratify-cli new <app-name>
+
+Commands:
+  new        Scaffold a new Stratify app
+`);
+        process.exit(1);
+    }
+    if (!name) {
+        console.error("Please provide an app name, e.g. npx stratify-cli new my-app");
+        process.exit(1);
+    }
+    const templateDir = resolve(new URL("../template", import.meta.url).pathname);
+    await runNew({ appName: name, templateDir });
+}
+main().catch((err) => {
+    console.error(err?.stack || String(err));
+    process.exit(1);
+});

package/dist/new.js

@@ -0,0 +1,48 @@
+import { promises as fs } from "node:fs";
+import { join, resolve } from "node:path";
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function copyDir(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const e of entries) {
+        const s = join(src, e.name);
+        const d = join(dest, e.name);
+        if (e.isDirectory()) {
+            await copyDir(s, d);
+        }
+        else if (e.isFile()) {
+            await fs.copyFile(s, d);
+        }
+    }
+}
+async function replaceFileContent(p, replacer) {
+    const s = await fs.readFile(p, "utf8");
+    await fs.writeFile(p, replacer(s), "utf8");
+}
+export async function runNew({ appName, templateDir }) {
+    const target = resolve(process.cwd(), appName);
+    if (await pathExists(target)) {
+        throw new Error(`Directory "${appName}" already exists.`);
+    }
+    await copyDir(templateDir, target);
+    const pkgPath = join(target, "package.json");
+    await replaceFileContent(pkgPath, (s) => s.replace(/"name":\s*".+?"/, `"name": "${appName}"`));
+    console.log(`\nScaffolded "${appName}" successfully.
+
+Next steps:
+
+  cd ${appName}
+  npm install
+  npm run dev
+
+Happy hacking with Stratify!
+`);
+}

package/dist/test/new.test.js

@@ -0,0 +1,54 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { promises as fs } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { mkdtemp, rm } from "node:fs/promises";
+import { runNew } from "../new";
+const TEMPLATE_FIXTURE = resolve("template");
+async function pathExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+describe("runNew()", () => {
+    test("copies template and replaces package name", async () => {
+        const tmpRoot = await mkdtemp(join(tmpdir(), "stratify-cli-"));
+        const appName = "my-app";
+        const target = join(tmpRoot, appName);
+        const prevCwd = process.cwd();
+        process.chdir(tmpRoot);
+        try {
+            await runNew({ appName, templateDir: TEMPLATE_FIXTURE });
+            const pkgPath = join(target, "package.json");
+            assert.ok(await pathExists(pkgPath), "package.json should exist");
+            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+            assert.equal(pkg.name, appName);
+            const srcDir = join(target, "src");
+            assert.ok(await pathExists(srcDir), "src/ should exist");
+        }
+        finally {
+            process.chdir(prevCwd);
+            await rm(tmpRoot, { recursive: true, force: true });
+        }
+    });
+    test("throws if target directory already exists", async () => {
+        const tmpRoot = await mkdtemp(join(tmpdir(), "stratify-cli-"));
+        const appName = "existing-app";
+        const target = join(tmpRoot, appName);
+        await fs.mkdir(target, { recursive: true });
+        const prevCwd = process.cwd();
+        process.chdir(tmpRoot);
+        try {
+            await assert.rejects(() => runNew({ appName, templateDir: TEMPLATE_FIXTURE }), /already exists/);
+        }
+        finally {
+            process.chdir(prevCwd);
+            await rm(tmpRoot, { recursive: true, force: true });
+        }
+    });
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@stratify/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "stratify-cli": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "template"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/bin.ts",
+    "test": "tsx --test src/**/*.test.ts",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build && npm run test"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "tsx": "^4.16.2",
+    "typescript": "^5.6.3"
+  }
+}

package/template/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all"
+}

package/template/README.md

@@ -0,0 +1,20 @@
+# Stratify App (Tasks)
+
+Generated with `@stratify/cli`.
+
+## Scripts
+- `npm run dev` — run with tsx
+- `npm run build` — compile TypeScript to `dist/`
+- `npm start` — run compiled app
+- `npm test` — run integration tests with tsx
+
+## Structure
+- `src/main.ts` — app entrypoint
+- `src/tasks` — domain components
+  - `tasks.module.ts` — module composition
+  - `providers/tasks-repository.provider.ts` — fake in-memory repository
+  - `controllers/tasks.controller.ts` — routes (GET/POST)
+  - `hooks/http.hooks.ts` — trivial HTTP hook
+  - `installers/cors.installer.ts` — enables CORS
+  - `adapters/version.adapter.ts` — exposes fastify.version
+- `test/tasks.integration.test.ts` — integration tests for tasks endpoints

package/template/eslint.config.js

@@ -0,0 +1,15 @@
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+import pluginImport from "eslint-plugin-import";
+
+export default [
+  { ignores: ["dist", "node_modules"] },
+  js.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    plugins: { import: pluginImport },
+    rules: {
+      "import/no-unresolved": "off"
+    }
+  }
+];

package/template/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "APP_NAME_WILL_BE_REPLACED",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/main.ts",
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/main.js",
+    "lint": "eslint .",
+    "test": "tsx --test"
+  },
+  "dependencies": {
+    "@fastify/cors": "^10.0.0",
+    "@sinclair/typebox": "^0.32.30",
+    "@stratify/core": "^0.1.1",
+    "close-with-grace": "2.3.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.13.0",
+    "eslint": "^9.13.0",
+    "eslint-plugin-import": "^2.31.0",
+    "prettier": "^3.3.3",
+    "tsx": "^4.16.2",
+    "typescript": "^5.6.3",
+    "typescript-eslint": "^8.8.1",
+    "@types/node": "24.7.2"
+  }
+}

package/template/src/main.ts

@@ -0,0 +1,26 @@
+import { createApp } from "@stratify/core";
+import closeWithGrace from "close-with-grace";
+
+import { tasksModule } from "./tasks/tasks.module.js";
+
+const app = await createApp({
+  root: tasksModule,
+  serverOptions: {
+    logger: true,
+  },
+});
+
+closeWithGrace({ delay: 500 }, async ({ err }) => {
+  if (err != null) {
+    app.log.error(err);
+  }
+
+  await app.close();
+});
+
+try {
+  await app.listen({ port: 3000 });
+} catch (err) {
+  app.log.error(err);
+  process.exit(1);
+}

package/template/src/tasks/adapters/version.adapter.ts

@@ -0,0 +1,11 @@
+import { createAdapter } from "@stratify/core";
+
+/**
+ * Exposes Fastify version for the current instance context.
+ */
+export const versionAdapter = createAdapter({
+  name: "version",
+  expose: ({ fastify }) => ({
+    version: fastify.version
+  })
+});

package/template/src/tasks/controllers/tasks.controller.ts

@@ -0,0 +1,50 @@
+import { createController } from "@stratify/core";
+import { Type } from "@sinclair/typebox";
+import { tasksRepository } from "../providers/tasks-repository.provider.js";
+
+export const tasksController = createController({
+  name: "tasks", // optional, used by tree printer
+  deps: { tasksRepository },
+  build: async ({ builder, deps }) => {
+    // GET /tasks
+    builder.addRoute({
+      method: "GET",
+      url: "/tasks",
+      handler: async () => {
+        return { tasks: await deps.tasksRepository.list() };
+      }
+    });
+
+    // GET /tasks/:id
+    builder.addRoute({
+      method: "GET",
+      url: "/tasks/:id",
+      schema: {
+        params: Type.Object({ id: Type.String() })
+      },
+      handler: async (req, reply) => {
+        const task = await deps.tasksRepository.get(req.params.id);
+        if (!task) {
+          return reply.code(404).send({ error: "Not Found" });
+        }
+        return task;
+      }
+    });
+
+    // POST /tasks
+    builder.addRoute({
+      method: "POST",
+      url: "/tasks",
+      schema: {
+        body: Type.Object({
+          title: Type.String({ minLength: 1 })
+        })
+      },
+      handler: async (req) => {
+        const { title } = req.body;
+        const created = await deps.tasksRepository.create(title);
+        return created;
+      }
+    });
+  }
+});

package/template/src/tasks/hooks/http.hooks.ts

@@ -0,0 +1,13 @@
+import { createHooks } from "@stratify/core";
+
+export const httpHooks = createHooks({
+  type: "http",
+  name: "http-core", // optional, used by tree printer
+  build: async ({ builder }) => {
+    // Example: add a simple security header for all responses
+    builder.addHook("onRequest", async (_req, reply) => {
+      reply.header("x-content-type-options", "nosniff");
+    });
+    // You can add more lifecycle hooks as needed.
+  }
+});

package/template/src/tasks/installers/cors.installer.ts

@@ -0,0 +1,15 @@
+import { createInstaller } from "@stratify/core";
+import cors from "@fastify/cors";
+
+/**
+ * @see https://github.com/fastify/fastify-cors
+ */
+export const corsInstaller = createInstaller({
+  name: "cors", // optional, used by tree printer
+  install: async ({ fastify }) => {
+    await fastify.register(cors, {
+      origin: true, // allow all origins for now
+      methods: ["GET", "POST", "PUT", "DELETE"]
+    });
+  }
+});

package/template/src/tasks/providers/tasks-repository.provider.ts

@@ -0,0 +1,32 @@
+import { createProvider } from "@stratify/core";
+
+export interface Task {
+  id: string;
+  title: string;
+  done: boolean;
+};
+
+function makeId() {
+  return Math.random().toString(36).slice(2, 9);
+}
+
+export const tasksRepository = createProvider({
+  name: "tasksRepository",
+  expose: async () => {
+    // Fake in-memory store
+    const store: Task[] = [
+      { id: "t1", title: "Read Stratify docs", done: false }
+    ];
+
+    return {
+      list: async (): Promise<Task[]> => store,
+      get: async (id: string): Promise<Task | undefined> =>
+        store.find((t) => t.id === id),
+      create: async (title: string): Promise<Task> => {
+        const task = { id: makeId(), title, done: false };
+        store.push(task);
+        return task;
+      }
+    };
+  }
+});

package/template/src/tasks/tasks.module.ts

@@ -0,0 +1,13 @@
+import { createModule } from "@stratify/core";
+import { tasksController } from "./controllers/tasks.controller.js";
+import { httpHooks } from "./hooks/http.hooks.js";
+import { corsInstaller } from "./installers/cors.installer.js";
+
+export const tasksModule = createModule({
+  name: "tasks",
+  encapsulate: true,
+  controllers: [tasksController],
+  hooks: [httpHooks],
+  installers: [corsInstaller],
+  subModules: []
+});

package/template/test/tasks.integration.test.ts

@@ -0,0 +1,41 @@
+import { describe, test } from "node:test";
+import assert from "node:assert";
+import { createApp } from "@stratify/core";
+import { tasksModule } from "../src/tasks/tasks.module.ts";
+
+describe("tasks routes", () => {
+  test("GET /tasks returns initial list", async () => {
+    const app = await createApp({ root: tasksModule });
+    const res = await app.inject({ method: "GET", url: "/tasks" });
+    assert.strictEqual(res.statusCode, 200);
+    const json = res.json();
+    assert.ok(Array.isArray(json.tasks));
+    assert.ok(json.tasks.length >= 1);
+    await app.close();
+  });
+
+  test("POST /tasks creates a task, then GET /tasks/:id retrieves it", async () => {
+    const app = await createApp({ root: tasksModule });
+
+    const createRes = await app.inject({
+      method: "POST",
+      url: "/tasks",
+      payload: { title: "Write tests" }
+    });
+    assert.strictEqual(createRes.statusCode, 200);
+    const created = createRes.json();
+    assert.ok(created.id);
+    assert.strictEqual(created.title, "Write tests");
+    assert.strictEqual(created.done, false);
+
+    const getRes = await app.inject({
+      method: "GET",
+      url: `/tasks/${created.id}`
+    });
+    assert.strictEqual(getRes.statusCode, 200);
+    const fetched = getRes.json();
+    assert.deepStrictEqual(fetched, created);
+
+    await app.close();
+  });
+});

package/template/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "declaration": false,
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}