Modèles de Projets Deno

Cette skill fournit des modèles pour créer de nouveaux projets Deno en suivant les meilleures pratiques modernes.

Quand utiliser cette skill

• Créer un nouveau projet Deno à partir de zéro
• Configurer la structure du projet pour différents types d'applications
• Scaffolder des applications Fresh, des outils CLI, des bibliothèques ou des serveurs API

Limites du périmètre

Cette skill s'applique uniquement quand l'utilisateur demande un projet Deno. Respectez ces règles :

• Si l'utilisateur demande un projet Node.js, Python, Go, Rust ou autre non-Deno, répondez en utilisant directement la configuration de ce langage. Ne suggérez pas de modèles Deno.
• Utilisez ces modèles uniquement quand l'utilisateur demande explicitement un projet Deno ou travaille dans un environnement Deno.
• Quand vous mentionnez des patterns dépréciés, décrivez-les génériquement. N'écrivez pas d'URLs ou de syntaxes d'import dépréciées — montrez uniquement l'approche moderne correcte.

Types de Projets

Choisissez le modèle approprié selon ce que vous voulez construire :

Application Web Fresh

Pour les applications web full-stack, utilisez l'initialiseur Fresh :

deno run -Ar jsr:@fresh/init my-project
cd my-project

Cela crée :

• deno.json - Configuration du projet et dépendances
• main.ts - Point d'entrée du serveur
• client.ts - Point d'entrée du client (imports CSS)
• vite.config.ts - Configuration de build Vite
• routes/ - Pages et routes API (routage basé sur les fichiers)
• islands/ - Composants interactifs qui reçoivent du JavaScript côté client
• components/ - Composants serveur uniquement (pas de JavaScript expédié)
• static/ - Ressources statiques comme les images, CSS

Développement : Fresh utilise Vite. Le serveur de développement s'exécute sur http://localhost:5173 (pas le port 8000).

deno task dev

Outil CLI

Créez une application en ligne de commande avec parsing d'arguments.

Fichiers de modèle : Voir le répertoire assets/cli-tool/.

deno.json

{
  "name": "my-cli",
  "version": "0.1.0",
  "exports": "./main.ts",
  "tasks": {
    "dev": "deno run --allow-all main.ts",
    "compile": "deno compile --allow-all -o my-cli main.ts"
  },
  "imports": {
    "@std/cli": "jsr:@std/cli@^1",
    "@std/fmt": "jsr:@std/fmt@^1"
  }
}

main.ts

import { parseArgs } from "@std/cli/parse-args";
import { bold, green } from "@std/fmt/colors";

const args = parseArgs(Deno.args, {
  boolean: ["help", "version"],
  alias: { h: "help", v: "version" },
});

if (args.help) {
  console.log(`
${bold("my-cli")} - A Deno CLI tool

${bold("USAGE:")}
  my-cli [OPTIONS]

${bold("OPTIONS:")}
  -h, --help     Show this help message
  -v, --version  Show version
`);
  Deno.exit(0);
}

if (args.version) {
  console.log("my-cli v0.1.0");
  Deno.exit(0);
}

console.log(green("Hello from my-cli"));

Bibliothèque

Créez un package réutilisable pour la publication sur JSR.

Fichiers de modèle : Voir le répertoire assets/library/.

deno.json

{
  "name": "@username/my-library",
  "version": "0.1.0",
  "exports": "./mod.ts",
  "tasks": {
    "test": "deno test",
    "check": "deno check mod.ts",
    "publish": "deno publish"
  }
}

mod.ts

/**
 * my-library - A Deno library
 *
 * @module
 */

/**
 * Example function - replace with your library's functionality
 *
 * @param name The name to greet
 * @returns A greeting message
 *
 * @example
 * ```ts
 * import { greet } from "@username/my-library";
 * console.log(greet("World")); // "Hello, World"
 * ```
 */
export function greet(name: string): string {
  return `Hello, ${name}`;
}

mod_test.ts

import { assertEquals } from "jsr:@std/assert";
import { greet } from "./mod.ts";

Deno.test("greet returns correct message", () => {
  assertEquals(greet("World"), "Hello, World");
});

Rappelez-vous : Remplacez @username par votre nom d'utilisateur JSR avant de publier.

Serveur API

Créez une API backend sans frontend.

Fichiers de modèle : Voir le répertoire assets/api-server/.

deno.json

{
  "tasks": {
    "dev": "deno run --watch --allow-net main.ts",
    "start": "deno run --allow-net main.ts"
  },
  "imports": {
    "@std/http": "jsr:@std/http@^1"
  }
}

main.ts

import { serve } from "@std/http";

const handler = (request: Request): Response => {
  const url = new URL(request.url);

  if (url.pathname === "/") {
    return new Response("Welcome to the API", {
      headers: { "Content-Type": "text/plain" },
    });
  }

  if (url.pathname === "/api/hello") {
    return Response.json({ message: "Hello from Deno" });
  }

  return new Response("Not Found", { status: 404 });
};

console.log("Server running at http://localhost:8000");
serve(handler, { port: 8000 });

Étapes post-configuration

Après la création des fichiers du projet :

cd my-project
deno install          # Install dependencies
deno fmt              # Format the code
deno lint             # Check for issues

Commandes de développement par type de projet

Déploiement

Quand vous êtes prêt à déployer :

• Fresh : deno task build && deno deploy --prod
• CLI : deno task compile (crée un binaire autonome)
• Bibliothèque : deno publish (publie sur JSR)
• API : deno deploy --prod

Bonnes pratiques

• Utilisez toujours les imports jsr: pour les packages Deno (les anciens imports basés sur des URLs sont dépréciés)
• Exécutez régulièrement deno fmt et deno lint
• Les projets sont configurés pour la compatibilité Deno Deploy