@lastbrain/app 0.1.8 → 0.1.9

package/src/scripts/module-create.ts

@@ -0,0 +1,809 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+
+interface PageConfig {
+  section: "public" | "auth" | "admin";
+  path: string;
+  name: string;
+}
+
+interface TableConfig {
+  name: string;
+  sections: ("public" | "auth" | "admin")[];
+}
+
+interface ModuleConfig {
+  slug: string;
+  moduleName: string;
+  pages: PageConfig[];
+  tables: TableConfig[];
+}
+
+/**
+ * Parse une chaîne de pages séparées par des virgules
+ * Ex: "legal, privacy, terms" => ["legal", "privacy", "terms"]
+ */
+function parsePagesList(input: string): string[] {
+  if (!input || input.trim() === "") return [];
+  return input
+    .split(",")
+    .map((p) => p.trim())
+    .filter((p) => p.length > 0);
+}
+
+/**
+ * Parse une chaîne de tables séparées par des virgules
+ * Ex: "settings, users" => ["settings", "users"]
+ */
+function parseTablesList(input: string): string[] {
+  if (!input || input.trim() === "") return [];
+  return input
+    .split(",")
+    .map((t) => t.trim())
+    .filter((t) => t.length > 0);
+}
+
+/**
+ * Génère le contenu du package.json
+ */
+function generatePackageJson(moduleName: string, slug: string): string {
+  const buildConfigExport = `./${slug}.build.config`;
+  return JSON.stringify(
+    {
+      name: moduleName,
+      version: "0.1.0",
+      private: false,
+      type: "module",
+      main: "dist/index.js",
+      types: "dist/index.d.ts",
+      files: ["dist", "supabase"],
+      scripts: {
+        build: "tsc -p tsconfig.json",
+        dev: "tsc -p tsconfig.json --watch",
+      },
+      dependencies: {
+        "@lastbrain/core": "workspace:0.1.0",
+        "@lastbrain/ui": "workspace:0.1.0",
+        react: "^19.0.0",
+        "lucide-react": "^0.554.0",
+        "react-dom": "^19.0.0",
+      },
+      devDependencies: {
+        typescript: "^5.4.0",
+      },
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js",
+        },
+        "./server": {
+          types: "./dist/server.d.ts",
+          default: "./dist/server.js",
+        },
+        [buildConfigExport]: {
+          types: `./dist/${slug}.build.config.d.ts`,
+          default: `./dist/${slug}.build.config.js`,
+        },
+        "./api/*": {
+          types: "./dist/api/*.d.ts",
+          default: "./dist/api/*.js",
+        },
+      },
+      sideEffects: false,
+    },
+    null,
+    2
+  );
+}
+
+/**
+ * Génère le contenu du tsconfig.json
+ */
+function generateTsConfig(): string {
+  return JSON.stringify(
+    {
+      extends: "../../tsconfig.base.json",
+      compilerOptions: {
+        outDir: "dist",
+        rootDir: "src",
+        declaration: true,
+      },
+      include: ["src"],
+    },
+    null,
+    2
+  );
+}
+
+/**
+ * Génère le contenu du fichier build.config.ts
+ */
+function generateBuildConfig(config: ModuleConfig): string {
+  const { moduleName, pages, tables } = config;
+
+  // Générer la liste des pages
+  const pagesConfig = pages.map((page) => {
+    const componentName = page.name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    return `    {
+      section: "${page.section}",
+      path: "${page.path}",
+      componentExport: "${componentName}Page",
+    }`;
+  });
+
+  // Générer la liste des APIs
+  const apisConfig: string[] = [];
+  for (const table of tables) {
+    for (const section of table.sections) {
+      const methods = ["GET", "POST", "PUT", "DELETE"];
+      for (const method of methods) {
+        apisConfig.push(`    {
+      method: "${method}",
+      path: "/api/${section}/${table.name}",
+      handlerExport: "${method}",
+      entryPoint: "api/${section}/${table.name}",
+      authRequired: ${section !== "public"},
+    }`);
+      }
+    }
+  }
+
+  // Générer les menus par section
+  const menuSections: { section: string; items: string[] }[] = [];
+  
+  // Menu public
+  const publicPages = pages.filter(p => p.section === "public");
+  if (publicPages.length > 0) {
+    const publicMenuItems = publicPages.map((page, index) => {
+      const title = page.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+      return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "FileText",
+        path: "${page.path}",
+        order: ${index + 1},
+      }`;
+    });
+    menuSections.push({ section: "public", items: publicMenuItems });
+  }
+
+  // Menu auth
+  const authPages = pages.filter(p => p.section === "auth");
+  if (authPages.length > 0) {
+    const authMenuItems = authPages.map((page, index) => {
+      const title = page.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+      return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "FileText",
+        path: "${page.path}",
+        order: ${index + 1},
+      }`;
+    });
+    menuSections.push({ section: "auth", items: authMenuItems });
+  }
+
+  // Menu admin
+  const adminPages = pages.filter(p => p.section === "admin");
+  if (adminPages.length > 0) {
+    const adminMenuItems = adminPages.map((page, index) => {
+      const title = page.name
+        .split("-")
+        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(" ");
+      return `      {
+        title: "${title}",
+        description: "Page ${title}",
+        icon: "Settings",
+        path: "${page.path}",
+        order: ${index + 1},
+      }`;
+    });
+    menuSections.push({ section: "admin", items: adminMenuItems });
+  }
+
+  // Générer la configuration menu
+  const menuConfig = menuSections.length > 0 
+    ? `,
+  menu: {
+${menuSections.map(({ section, items }) => `    ${section}: [
+${items.join(",\n")}
+    ]`).join(",\n")}
+  }` 
+    : "";
+
+  return `import type { ModuleBuildConfig } from "@lastbrain/core";
+
+const buildConfig: ModuleBuildConfig = {
+  moduleName: "${moduleName}",
+  pages: [
+${pagesConfig.join(",\n")}
+  ],
+  apis: [
+${apisConfig.join(",\n")}
+  ],
+  migrations: {
+    enabled: true,
+    priority: 30,
+    path: "supabase/migrations",
+    files: ${tables.length > 0 ? `["001_${config.slug}_init.sql"]` : "[]"},
+  }${menuConfig},
+};
+
+export default buildConfig;
+`;
+}
+
+/**
+ * Génère le contenu du fichier index.ts
+ */
+function generateIndexTs(pages: PageConfig[]): string {
+  const exports = pages.map((page) => {
+    const componentName = page.name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    const fileName = page.name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    return `export { ${componentName}Page } from "./web/${page.section}/${fileName}Page.js";`;
+  });
+
+  return `// Client Components
+${exports.join("\n")}
+
+// Configuration de build
+export { default as buildConfig } from "./build.config.js";
+`;
+}
+
+/**
+ * Génère le contenu du fichier server.ts
+ */
+function generateServerTs(tables: TableConfig[]): string {
+  const exports: string[] = [];
+
+  for (const table of tables) {
+    for (const section of table.sections) {
+      exports.push(
+        `export { GET, POST, PUT, DELETE } from "./api/${section}/${table.name}.js";`
+      );
+    }
+  }
+
+  return `// Server-only exports (Route Handlers, Server Actions, etc.)
+${exports.join("\n")}
+`;
+}
+
+/**
+ * Génère le contenu d'une page
+ */
+function generatePageComponent(pageName: string, section: string): string {
+  const componentName = pageName
+    .split("-")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join("");
+
+  return `"use client";
+
+import { Card, CardBody, CardHeader } from "@lastbrain/ui";
+
+export function ${componentName}Page() {
+  return (
+    <div className="container mx-auto p-6">
+      <Card>
+        <CardHeader>
+          <h1 className="text-2xl font-bold">${componentName}</h1>
+        </CardHeader>
+        <CardBody>
+          <p className="text-default-600">
+            Contenu de la page ${pageName} (section: ${section})
+          </p>
+        </CardBody>
+      </Card>
+    </div>
+  );
+}
+`;
+}
+
+/**
+ * Génère le contenu d'une route API CRUD
+ */
+function generateApiRoute(tableName: string, section: string): string {
+  const authRequired = section !== "public";
+
+  return `import { getSupabaseServerClient } from "@lastbrain/core/server";
+
+const jsonResponse = (payload: unknown, status = 200) => {
+  return new Response(JSON.stringify(payload), {
+    headers: {
+      "content-type": "application/json"
+    },
+    status
+  });
+};
+
+/**
+ * GET - Liste tous les enregistrements de ${tableName}
+ */
+export async function GET(request: Request) {
+  const supabase = await getSupabaseServerClient();
+  ${authRequired ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  ` : ""}
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .select("*");
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data });
+}
+
+/**
+ * POST - Crée un nouvel enregistrement dans ${tableName}
+ */
+export async function POST(request: Request) {
+  const supabase = await getSupabaseServerClient();
+  ${authRequired ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  ` : ""}
+
+  const body = await request.json();
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .insert(body)
+    .select()
+    .single();
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data }, 201);
+}
+
+/**
+ * PUT - Met à jour un enregistrement dans ${tableName}
+ */
+export async function PUT(request: Request) {
+  const supabase = await getSupabaseServerClient();
+  ${authRequired ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  ` : ""}
+
+  const body = await request.json();
+  const { id, ...updateData } = body;
+
+  if (!id) {
+    return jsonResponse({ error: "ID requis pour la mise à jour" }, 400);
+  }
+
+  const { data, error } = await supabase
+    .from("${tableName}")
+    .update(updateData)
+    .eq("id", id)
+    .select()
+    .single();
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ data });
+}
+
+/**
+ * DELETE - Supprime un enregistrement de ${tableName}
+ */
+export async function DELETE(request: Request) {
+  const supabase = await getSupabaseServerClient();
+  ${authRequired ? `
+  const { data: { user }, error: authError } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return jsonResponse({ error: "Non authentifié" }, 401);
+  }
+  ` : ""}
+
+  const { searchParams } = new URL(request.url);
+  const id = searchParams.get("id");
+
+  if (!id) {
+    return jsonResponse({ error: "ID requis pour la suppression" }, 400);
+  }
+
+  const { error } = await supabase
+    .from("${tableName}")
+    .delete()
+    .eq("id", id);
+
+  if (error) {
+    return jsonResponse({ error: error.message }, 400);
+  }
+
+  return jsonResponse({ success: true });
+}
+`;
+}
+
+/**
+ * Génère le contenu d'un fichier de migration SQL
+ */
+function generateMigration(tables: TableConfig[], slug: string): string {
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .split(".")[0]
+    .replace("T", "");
+
+  const tablesSQL = tables
+    .map((table) => {
+      return `-- ===========================================================================
+-- Table: public.${table.name}
+-- ===========================================================================
+CREATE TABLE IF NOT EXISTS public.${table.name} (
+  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  title text NOT NULL,
+  description text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+-- RLS
+ALTER TABLE public.${table.name} ENABLE ROW LEVEL SECURITY;
+
+-- Politique: Les utilisateurs peuvent voir leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_select ON public.${table.name};
+CREATE POLICY ${table.name}_owner_select ON public.${table.name}
+  FOR SELECT TO authenticated
+  USING (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent créer leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_insert ON public.${table.name};
+CREATE POLICY ${table.name}_owner_insert ON public.${table.name}
+  FOR INSERT TO authenticated
+  WITH CHECK (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent modifier leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_update ON public.${table.name};
+CREATE POLICY ${table.name}_owner_update ON public.${table.name}
+  FOR UPDATE TO authenticated
+  USING (owner_id = auth.uid())
+  WITH CHECK (owner_id = auth.uid());
+
+-- Politique: Les utilisateurs peuvent supprimer leurs propres enregistrements
+DROP POLICY IF EXISTS ${table.name}_owner_delete ON public.${table.name};
+CREATE POLICY ${table.name}_owner_delete ON public.${table.name}
+  FOR DELETE TO authenticated
+  USING (owner_id = auth.uid());
+
+-- Trigger updated_at
+DROP TRIGGER IF EXISTS set_${table.name}_updated_at ON public.${table.name};
+CREATE TRIGGER set_${table.name}_updated_at
+  BEFORE UPDATE ON public.${table.name}
+  FOR EACH ROW EXECUTE FUNCTION public.set_updated_at();
+
+-- Index
+CREATE INDEX IF NOT EXISTS idx_${table.name}_owner_id ON public.${table.name}(owner_id);
+
+-- Grants
+GRANT SELECT, INSERT, UPDATE, DELETE ON public.${table.name} TO service_role;
+`;
+    })
+    .join("\n\n");
+
+  return `-- ${slug} module initial migration
+-- Auto-generated by module-create.ts
+-- NOTE: uses helper function set_updated_at() from base migration
+
+-- ===========================================================================
+-- Helper: set_updated_at trigger function (if not already present)
+-- ===========================================================================
+CREATE OR REPLACE FUNCTION public.set_updated_at()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+BEGIN
+  NEW.updated_at := now();
+  RETURN NEW;
+END;
+$$;
+
+${tablesSQL}
+`;
+}
+
+/**
+ * Crée la structure du module
+ */
+async function createModuleStructure(config: ModuleConfig, rootDir: string) {
+  const moduleDir = path.join(rootDir, "packages", config.slug);
+
+  console.log(chalk.blue(`\n📦 Création du module ${config.slug}...\n`));
+
+  // Créer la structure de base
+  await fs.ensureDir(moduleDir);
+  await fs.ensureDir(path.join(moduleDir, "src"));
+  await fs.ensureDir(path.join(moduleDir, "src", "web"));
+  await fs.ensureDir(path.join(moduleDir, "src", "api"));
+  await fs.ensureDir(path.join(moduleDir, "supabase", "migrations"));
+
+  // Créer package.json
+  console.log(chalk.yellow("  📄 package.json"));
+  await fs.writeFile(
+    path.join(moduleDir, "package.json"),
+    generatePackageJson(config.moduleName, config.slug)
+  );
+
+  // Créer tsconfig.json
+  console.log(chalk.yellow("  📄 tsconfig.json"));
+  await fs.writeFile(
+    path.join(moduleDir, "tsconfig.json"),
+    generateTsConfig()
+  );
+
+  // Créer {slug}.build.config.ts
+  const buildConfigFileName = `${config.slug}.build.config.ts`;
+  console.log(chalk.yellow(`  📄 src/${buildConfigFileName}`));
+  await fs.writeFile(
+    path.join(moduleDir, "src", buildConfigFileName),
+    generateBuildConfig(config)
+  );
+
+  // Créer index.ts
+  console.log(chalk.yellow("  📄 src/index.ts"));
+  await fs.writeFile(
+    path.join(moduleDir, "src", "index.ts"),
+    generateIndexTs(config.pages)
+  );
+
+  // Créer server.ts
+  console.log(chalk.yellow("  📄 src/server.ts"));
+  await fs.writeFile(
+    path.join(moduleDir, "src", "server.ts"),
+    generateServerTs(config.tables)
+  );
+
+  // Créer les pages
+  console.log(chalk.blue("\n📄 Création des pages..."));
+  for (const page of config.pages) {
+    const pagePath = path.join(moduleDir, "src", "web", page.section);
+    await fs.ensureDir(pagePath);
+
+    const componentName = page.name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    const fileName = `${componentName}Page.tsx`;
+
+    console.log(chalk.yellow(`  📄 src/web/${page.section}/${fileName}`));
+    await fs.writeFile(
+      path.join(pagePath, fileName),
+      generatePageComponent(page.name, page.section)
+    );
+  }
+
+  // Créer les routes API
+  if (config.tables.length > 0) {
+    console.log(chalk.blue("\n🔌 Création des routes API..."));
+    for (const table of config.tables) {
+      for (const section of table.sections) {
+        const apiPath = path.join(moduleDir, "src", "api", section);
+        await fs.ensureDir(apiPath);
+
+        const fileName = `${table.name}.ts`;
+        console.log(chalk.yellow(`  📄 src/api/${section}/${fileName}`));
+        await fs.writeFile(
+          path.join(apiPath, fileName),
+          generateApiRoute(table.name, section)
+        );
+      }
+    }
+  }
+
+  // Créer les migrations
+  if (config.tables.length > 0) {
+    console.log(chalk.blue("\n🗄️  Création des migrations..."));
+    const timestamp = new Date()
+      .toISOString()
+      .replace(/[-:]/g, "")
+      .split(".")[0]
+      .replace("T", "");
+
+    const migrationFileName = `${timestamp}_${config.slug}_init.sql`;
+    console.log(
+      chalk.yellow(`  📄 supabase/migrations/${migrationFileName}`)
+    );
+    await fs.writeFile(
+      path.join(moduleDir, "supabase", "migrations", migrationFileName),
+      generateMigration(config.tables, config.slug)
+    );
+  }
+
+  console.log(chalk.green(`\n✅ Module ${config.slug} créé avec succès!\n`));
+  console.log(chalk.gray(`📂 Emplacement: ${moduleDir}\n`));
+  console.log(chalk.blue("Prochaines étapes:"));
+  console.log(chalk.gray(`  1. cd ${moduleDir}`));
+  console.log(chalk.gray(`  2. pnpm install`));
+  console.log(chalk.gray(`  3. pnpm build`));
+  console.log(
+    chalk.gray(
+      `  4. Ajouter le module à votre app avec: pnpm lastbrain add ${config.slug.replace("module-", "")}\n`
+    )
+  );
+}
+
+/**
+ * Point d'entrée du script
+ */
+export async function createModule() {
+  console.log(chalk.blue("\n🚀 Création d'un nouveau module LastBrain\n"));
+
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "slug",
+      message: "Nom du module (sera préfixé par 'module-'):",
+      validate: (input) => {
+        if (!input || input.trim() === "") {
+          return "Le nom du module est requis";
+        }
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return "Le nom doit contenir uniquement des lettres minuscules, chiffres et tirets";
+        }
+        return true;
+      },
+      filter: (input: string) => input.trim().toLowerCase(),
+    },
+    {
+      type: "input",
+      name: "pagesPublic",
+      message:
+        "Pages publiques (séparées par des virgules, ex: legal, privacy, terms):",
+      default: "",
+    },
+    {
+      type: "input",
+      name: "pagesAuth",
+      message:
+        "Pages authentifiées (séparées par des virgules, ex: dashboard, profile):",
+      default: "",
+    },
+    {
+      type: "input",
+      name: "pagesAdmin",
+      message:
+        "Pages admin (séparées par des virgules, ex: settings, users):",
+      default: "",
+    },
+    {
+      type: "input",
+      name: "tables",
+      message:
+        "Tables (séparées par des virgules, ex: settings, notifications):",
+      default: "",
+    },
+  ]);
+
+  // Construire la configuration du module
+  const slug = `module-${answers.slug}`;
+  const moduleName = `@lastbrain/${slug}`;
+
+  const pages: PageConfig[] = [];
+
+  // Pages publiques
+  const publicPages = parsePagesList(answers.pagesPublic);
+  for (const pageName of publicPages) {
+    pages.push({
+      section: "public",
+      path: `/${pageName}`,
+      name: pageName,
+    });
+  }
+
+  // Pages auth
+  const authPages = parsePagesList(answers.pagesAuth);
+  for (const pageName of authPages) {
+    pages.push({
+      section: "auth",
+      path: `/${pageName}`,
+      name: pageName,
+    });
+  }
+
+  // Pages admin
+  const adminPages = parsePagesList(answers.pagesAdmin);
+  for (const pageName of adminPages) {
+    pages.push({
+      section: "admin",
+      path: `/${pageName}`,
+      name: pageName,
+    });
+  }
+
+  // Tables
+  const tableNames = parseTablesList(answers.tables);
+  const tables: TableConfig[] = [];
+
+  for (const tableName of tableNames) {
+    // Déterminer dans quelles sections créer les APIs pour cette table
+    const sections: ("public" | "auth" | "admin")[] = [];
+
+    if (publicPages.length > 0) sections.push("public");
+    if (authPages.length > 0) sections.push("auth");
+    if (adminPages.length > 0) sections.push("admin");
+
+    // Si aucune page n'est définie, créer au moins les APIs auth
+    if (sections.length === 0) sections.push("auth");
+
+    tables.push({
+      name: tableName,
+      sections,
+    });
+  }
+
+  const config: ModuleConfig = {
+    slug,
+    moduleName,
+    pages,
+    tables,
+  };
+
+  // Trouver le répertoire racine du workspace (chercher pnpm-workspace.yaml)
+  let rootDir = process.cwd();
+  let attempts = 0;
+  const maxAttempts = 5;
+  
+  while (attempts < maxAttempts) {
+    const workspaceFile = path.join(rootDir, "pnpm-workspace.yaml");
+    if (fs.existsSync(workspaceFile)) {
+      break;
+    }
+    rootDir = path.resolve(rootDir, "..");
+    attempts++;
+  }
+
+  if (attempts === maxAttempts) {
+    console.error(chalk.red("❌ Impossible de trouver le répertoire racine du workspace (pnpm-workspace.yaml non trouvé)"));
+    process.exit(1);
+  }
+
+  // Créer le module
+  await createModuleStructure(config, rootDir);
+}
+
+// Exécuter le script si appelé directement
+if (import.meta.url === `file://${process.argv[1]}`) {
+  createModule().catch((error) => {
+    console.error(chalk.red("❌ Erreur:"), error);
+    process.exit(1);
+  });
+}