@dartix-software-solutions/create-fullstack-app 2.0.10 → 2.0.13

package/dist/backends/fastapi/templates/app/core/config.py.hbs

@@ -1,13 +1,13 @@
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
-
-    app_name: str = "{{projectName}} API"
-    port: int = 8000
-    cors_origin: str = "http://localhost:5173"
-    debug: bool = True
-
-
-settings = Settings()
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+
+    app_name: str = "{{projectName}} API"
+    port: int = 8000
+    cors_origin: str = "http://localhost:5173"
+    debug: bool = True
+
+
+settings = Settings()

package/dist/backends/fastapi/templates/app/main.py.hbs

@@ -1,31 +1,31 @@
-from contextlib import asynccontextmanager
-
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from app.core.config import settings
-from app.routers import health, users
-
-
-@asynccontextmanager
-async def lifespan(_app: FastAPI):
-    yield
-
-
-app = FastAPI(
-    title=settings.app_name,
-    lifespan=lifespan,
-    docs_url="/docs" if settings.debug else None,
-    redoc_url="/redoc" if settings.debug else None,
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=[settings.cors_origin],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-app.include_router(health.router, tags=["health"])
-app.include_router(users.router, prefix="/users", tags=["users"])
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.routers import health, users
+
+
+@asynccontextmanager
+async def lifespan(_app: FastAPI):
+    yield
+
+
+app = FastAPI(
+    title=settings.app_name,
+    lifespan=lifespan,
+    docs_url="/docs" if settings.debug else None,
+    redoc_url="/redoc" if settings.debug else None,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[settings.cors_origin],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(health.router, tags=["health"])
+app.include_router(users.router, prefix="/users", tags=["users"])

package/dist/backends/fastapi/templates/app/routers/health.py.hbs

@@ -1,8 +1,8 @@
-from fastapi import APIRouter
-
-router = APIRouter()
-
-
-@router.get("/health")
-async def health():
-    return {"status": "ok"}
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/health")
+async def health():
+    return {"status": "ok"}

package/dist/backends/fastapi/templates/app/routers/users.py.hbs

@@ -1,30 +1,30 @@
-from fastapi import APIRouter, HTTPException, status
-
-from app.schemas.user import UserCreate, UserRead
-
-router = APIRouter()
-
-_db: list[UserRead] = [
-    UserRead(id=1, email="demo@example.com", name="Demo User"),
-]
-
-
-@router.get("/", response_model=list[UserRead])
-async def list_users() -> list[UserRead]:
-    return list(_db)
-
-
-@router.get("/{user_id}", response_model=UserRead)
-async def get_user(user_id: int) -> UserRead:
-    for user in _db:
-        if user.id == user_id:
-            return user
-    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
-
-
-@router.post("/", response_model=UserRead, status_code=status.HTTP_201_CREATED)
-async def create_user(body: UserCreate) -> UserRead:
-    next_id = max((u.id for u in _db), default=0) + 1
-    user = UserRead(id=next_id, email=body.email, name=body.name)
-    _db.append(user)
-    return user
+from fastapi import APIRouter, HTTPException, status
+
+from app.schemas.user import UserCreate, UserRead
+
+router = APIRouter()
+
+_db: list[UserRead] = [
+    UserRead(id=1, email="demo@example.com", name="Demo User"),
+]
+
+
+@router.get("/", response_model=list[UserRead])
+async def list_users() -> list[UserRead]:
+    return list(_db)
+
+
+@router.get("/{user_id}", response_model=UserRead)
+async def get_user(user_id: int) -> UserRead:
+    for user in _db:
+        if user.id == user_id:
+            return user
+    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="User not found")
+
+
+@router.post("/", response_model=UserRead, status_code=status.HTTP_201_CREATED)
+async def create_user(body: UserCreate) -> UserRead:
+    next_id = max((u.id for u in _db), default=0) + 1
+    user = UserRead(id=next_id, email=body.email, name=body.name)
+    _db.append(user)
+    return user

package/dist/backends/fastapi/templates/app/schemas/user.py.hbs

@@ -1,12 +1,12 @@
-from pydantic import BaseModel, EmailStr, Field
-
-
-class UserRead(BaseModel):
-    id: int = Field(..., ge=1)
-    email: EmailStr
-    name: str
-
-
-class UserCreate(BaseModel):
-    email: EmailStr
-    name: str
+from pydantic import BaseModel, EmailStr, Field
+
+
+class UserRead(BaseModel):
+    id: int = Field(..., ge=1)
+    email: EmailStr
+    name: str
+
+
+class UserCreate(BaseModel):
+    email: EmailStr
+    name: str

package/dist/backends/fastapi/templates/requirements.txt.hbs

@@ -1,6 +1,6 @@
-fastapi>=0.115.0
-uvicorn[standard]>=0.32.0
-pydantic-settings>=2.6.0
-python-dotenv>=1.0.0
-gunicorn>=23.0.0
-email-validator>=2.2.0
+fastapi>=0.115.0
+uvicorn[standard]>=0.32.0
+pydantic-settings>=2.6.0
+python-dotenv>=1.0.0
+gunicorn>=23.0.0
+email-validator>=2.2.0

package/dist/bin/create-fullstack-app.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "../chunk-YB5MXG5R.js";
+} from "../chunk-Z7MIDMEN.js";
 
 // src/bin/create-fullstack-app.ts
 main().catch((error) => {

package/dist/{chunk-YB5MXG5R.js → chunk-Z7MIDMEN.js}

@@ -1970,11 +1970,9 @@ var SingleAppLayout = class {
     if (isFullstack) {
       const feDir = context.hasMobile ? "mobile" : "client";
       const scripts = {
-        dev: `concurrently "npm run dev:${context.hasMobile ? "mobile" : "client"}" "npm run dev:server"`,
-        [`dev:${context.hasMobile ? "mobile" : "client"}`]: `cd ${feDir} && npm run dev`,
-        "dev:server": "cd server && npm run dev",
-        build: `cd ${feDir} && npm run build && cd ../server && npm run build`,
-        lint: `cd ${feDir} && npm run lint && cd ../server && npm run lint`
+        dev: "npm run dev --workspaces --if-present --parallel",
+        build: "npm run build --workspaces --if-present",
+        lint: "npm run lint --workspaces --if-present"
       };
       if (context.hasHusky) {
         scripts.prepare = "husky";
@@ -1986,10 +1984,8 @@ var SingleAppLayout = class {
             name: context.projectName,
             version: "0.1.0",
             private: true,
-            scripts,
-            devDependencies: {
-              concurrently: "^9.1.0"
-            }
+            workspaces: [feDir, "server"],
+            scripts
           },
           null,
           2
@@ -2931,34 +2927,36 @@ function resolveDependencies(plugins, packageJsonTargets, context) {
     });
   }
   for (const plugin of plugins) {
-    const targetKey = resolveTargetForPlugin(plugin, packageJsonTargets, context);
-    if (!targetKey) {
+    const targetKeys = resolveTargetsForPlugin(plugin, packageJsonTargets, context);
+    if (targetKeys.length === 0) {
       logger.warn(
         `Could not resolve target package.json for plugin "${plugin.meta.id}" (category: ${plugin.meta.category})`
       );
       continue;
     }
-    const merged = result.get(targetKey);
-    if (!merged) continue;
-    for (const dep of plugin.meta.deps) {
-      if (merged.dependencies[dep.name]) {
-        if (merged.dependencies[dep.name] !== dep.version) {
-          logger.warn(
-            `Dependency version conflict for "${dep.name}": "${merged.dependencies[dep.name]}" vs "${dep.version}" (from ${plugin.meta.id})`
-          );
+    for (const targetKey of targetKeys) {
+      const merged = result.get(targetKey);
+      if (!merged) continue;
+      for (const dep of plugin.meta.deps) {
+        if (merged.dependencies[dep.name]) {
+          if (merged.dependencies[dep.name] !== dep.version) {
+            logger.warn(
+              `Dependency version conflict for "${dep.name}": "${merged.dependencies[dep.name]}" vs "${dep.version}" (from ${plugin.meta.id})`
+            );
+          }
         }
+        merged.dependencies[dep.name] = dep.version;
       }
-      merged.dependencies[dep.name] = dep.version;
-    }
-    for (const dep of plugin.meta.devDeps) {
-      if (merged.devDependencies[dep.name]) {
-        if (merged.devDependencies[dep.name] !== dep.version) {
-          logger.warn(
-            `Dev dependency version conflict for "${dep.name}": "${merged.devDependencies[dep.name]}" vs "${dep.version}" (from ${plugin.meta.id})`
-          );
+      for (const dep of plugin.meta.devDeps) {
+        if (merged.devDependencies[dep.name]) {
+          if (merged.devDependencies[dep.name] !== dep.version) {
+            logger.warn(
+              `Dev dependency version conflict for "${dep.name}": "${merged.devDependencies[dep.name]}" vs "${dep.version}" (from ${plugin.meta.id})`
+            );
+          }
         }
+        merged.devDependencies[dep.name] = dep.version;
       }
-      merged.devDependencies[dep.name] = dep.version;
     }
   }
   for (const [key, merged] of result) {
@@ -2969,7 +2967,21 @@ function resolveDependencies(plugins, packageJsonTargets, context) {
   }
   return result;
 }
-function resolveTargetForPlugin(plugin, packageJsonTargets, _context) {
+function resolveTargetsForPlugin(plugin, packageJsonTargets, context) {
+  if (plugin.meta.category === "devtools" && context.isSingleApp && context.isFullstack) {
+    const frontendTarget = packageJsonTargets.find((t) => t.target === TARGETS.FRONTEND)?.path;
+    const backendTarget = packageJsonTargets.find((t) => t.target === TARGETS.BACKEND)?.path;
+    return [frontendTarget, backendTarget].filter((p) => Boolean(p));
+  }
+  const single = resolveTargetForPlugin(plugin, packageJsonTargets, context);
+  return single ? [single] : [];
+}
+function resolveTargetForPlugin(plugin, packageJsonTargets, context) {
+  const inferredTarget = inferTargetFromPluginOutputs(plugin, context);
+  if (inferredTarget) {
+    const inferredPackage = packageJsonTargets.find((t) => t.target === inferredTarget);
+    if (inferredPackage) return inferredPackage.path;
+  }
   const categoryTarget = CATEGORY_TARGET_MAP[plugin.meta.category];
   if (!categoryTarget) {
     const rootTarget2 = packageJsonTargets.find((t) => t.target === TARGETS.ROOT);
@@ -2990,6 +3002,23 @@ function resolveTargetForPlugin(plugin, packageJsonTargets, _context) {
   const rootTarget = packageJsonTargets.find((t) => t.target === TARGETS.ROOT);
   return rootTarget?.path || packageJsonTargets[0]?.path || null;
 }
+function inferTargetFromPluginOutputs(plugin, context) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const entry of plugin.fileMap.files) {
+    if (!entry.when || entry.when(context)) {
+      targets.add(entry.target);
+    }
+  }
+  for (const injection of plugin.fileMap.injections) {
+    if (!injection.when || injection.when(context)) {
+      targets.add(injection.target);
+    }
+  }
+  if (targets.size === 1) {
+    return [...targets][0];
+  }
+  return null;
+}
 
 // src/generator/script-builder.ts
 function buildScripts2(plugins, packageJsonTargets, _context) {
@@ -3590,6 +3619,8 @@ function detectFileCollisions(activePlugins, context, pathResolver) {
 
 // src/generator/post-generate.ts
 import { execa } from "execa";
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
 
 // src/cli/ui/spinner.ts
 import ora from "ora";
@@ -3687,23 +3718,29 @@ async function runPostGenerate(outputDir, context, options) {
   if (!options.skipInstall) {
     const installCmd = getInstallCommand(context.packageManager);
     const [cmd, ...args] = installCmd.split(" ");
+    const installTargets = await getInstallTargets(outputDir, context);
     try {
-      await withSpinner(
-        `Installing dependencies with ${context.packageManager}...`,
-        async () => {
-          await execa(cmd, args, {
-            cwd: outputDir,
-            stdio: "pipe"
-          });
-        },
-        "Dependencies installed"
-      );
+      for (const target of installTargets) {
+        await withSpinner(
+          `Installing ${target.label} dependencies with ${context.packageManager}...`,
+          async () => {
+            await execa(cmd, args, {
+              cwd: target.cwd,
+              stdio: "pipe"
+            });
+          },
+          `${target.label} dependencies installed`
+        );
+      }
       installed = true;
     } catch (error) {
       logger.warn(`Failed to install dependencies: ${error.message}`);
       logger.info(`You can run "${installCmd}" manually`);
     }
   }
+  if (installed) {
+    await runBootstrapScripts(outputDir, context);
+  }
   const steps = buildNextSteps(context, installed);
   printPostGeneration(context.projectName, outputDir, context.packageManager, steps);
   return { installed, gitInitialized };
@@ -3722,7 +3759,11 @@ function buildNextSteps(context, installed) {
   }
   steps.push("Fill in your environment variable values");
   if (context.hasDatabase && context.hasPrisma) {
-    steps.push(`Set up database: ${pm} run db:migrate && ${pm} run db:seed`);
+    if (context.isFullstack) {
+      steps.push(`Set up database: cd server && ${pm} run db:migrate && ${pm} run db:seed`);
+    } else {
+      steps.push(`Set up database: ${pm} run db:migrate && ${pm} run db:seed`);
+    }
   }
   steps.push(`Start development: ${pm} run dev`);
   if (context.hasMobile) {
@@ -3730,6 +3771,100 @@ function buildNextSteps(context, installed) {
   }
   return steps;
 }
+async function getInstallTargets(outputDir, context) {
+  const packageDirs = await discoverPackageDirs(outputDir);
+  const targets = [];
+  for (const dir of packageDirs) {
+    if (!await hasInstallableDependencies(dir)) continue;
+    targets.push({
+      label: labelForInstallTarget(dir, outputDir, context),
+      cwd: dir
+    });
+  }
+  if (targets.length === 0) {
+    targets.push({ label: "project", cwd: outputDir });
+  }
+  return targets;
+}
+async function runBootstrapScripts(outputDir, context) {
+  const pm = context.packageManager;
+  const installTargets = await getInstallTargets(outputDir, context);
+  const safeBootstrapScripts = ["db:generate", "generate", "codegen", "graphql:codegen", "types:generate"];
+  for (const target of installTargets) {
+    try {
+      const packageJsonPath = join(target.cwd, "package.json");
+      const raw = await readFile(packageJsonPath, "utf8");
+      const pkg = JSON.parse(raw);
+      const scripts = pkg.scripts ?? {};
+      for (const scriptName of safeBootstrapScripts) {
+        if (!scripts[scriptName]) continue;
+        const [cmd, ...args] = `${pm} run ${scriptName}`.split(" ");
+        await withSpinner(
+          `Running ${target.label}:${scriptName}...`,
+          async () => {
+            await execa(cmd, args, {
+              cwd: target.cwd,
+              stdio: "pipe"
+            });
+          },
+          `${target.label}:${scriptName} completed`
+        );
+      }
+    } catch (error) {
+      logger.debug(`Bootstrap scripts skipped for ${target.label}: ${error.message}`);
+    }
+  }
+}
+async function discoverPackageDirs(outputDir) {
+  const dirs = [];
+  await walkForPackageJson(outputDir, outputDir, dirs);
+  const unique = [...new Set(dirs)];
+  unique.sort((a, b) => {
+    if (a === outputDir) return -1;
+    if (b === outputDir) return 1;
+    return a.localeCompare(b);
+  });
+  return unique;
+}
+async function walkForPackageJson(root, current, dirs) {
+  const entries = await readdir(current, { withFileTypes: true });
+  let hasPackageJson = false;
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name === "package.json") {
+      hasPackageJson = true;
+      break;
+    }
+  }
+  if (hasPackageJson) {
+    dirs.push(current);
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === "node_modules" || entry.name === ".git") continue;
+    await walkForPackageJson(root, join(current, entry.name), dirs);
+  }
+}
+function labelForInstallTarget(targetDir, outputDir, context) {
+  if (targetDir === outputDir) return "root";
+  if (targetDir === join(outputDir, "server")) return "server";
+  if (targetDir === join(outputDir, "client")) return "client";
+  if (targetDir === join(outputDir, "mobile")) return "mobile";
+  const relative = targetDir.slice(outputDir.length + 1).replace(/\\/g, "/");
+  if (relative) return relative;
+  return context.projectName;
+}
+async function hasInstallableDependencies(cwd) {
+  try {
+    const packageJsonPath = join(cwd, "package.json");
+    const raw = await readFile(packageJsonPath, "utf8");
+    const pkg = JSON.parse(raw);
+    const depsCount = Object.keys(pkg.dependencies ?? {}).length;
+    const devDepsCount = Object.keys(pkg.devDependencies ?? {}).length;
+    return depsCount > 0 || devDepsCount > 0;
+  } catch {
+    return false;
+  }
+}
 
 // src/generator/pipeline.ts
 var TOTAL_STEPS = 16;

package/dist/databases/mongodb/templates/connection.ts.hbs

@@ -1,15 +1,15 @@
-import { MongoClient } from 'mongodb';
-
-let client: MongoClient | null = null;
-
-export async function getMongoClient(): Promise<MongoClient> {
-  if (!client) {
-    const uri = process.env.MONGODB_URI;
-    if (!uri) {
-      throw new Error('MONGODB_URI is not set');
-    }
-    client = new MongoClient(uri);
-    await client.connect();
-  }
-  return client;
-}
+import { MongoClient } from 'mongodb';
+
+let client: MongoClient | null = null;
+
+export async function getMongoClient(): Promise<MongoClient> {
+  if (!client) {
+    const uri = process.env.MONGODB_URI;
+    if (!uri) {
+      throw new Error('MONGODB_URI is not set');
+    }
+    client = new MongoClient(uri);
+    await client.connect();
+  }
+  return client;
+}

package/dist/databases/mongodb/templates/health-check.ts.hbs

@@ -1,11 +1,11 @@
-import { getMongoClient } from './db-connection.js';
-
-export async function checkMongodbHealth(): Promise<boolean> {
-  try {
-    const c = await getMongoClient();
-    await c.db().command({ ping: 1 });
-    return true;
-  } catch {
-    return false;
-  }
-}
+import { getMongoClient } from './db-connection.js';
+
+export async function checkMongodbHealth(): Promise<boolean> {
+  try {
+    const c = await getMongoClient();
+    await c.db().command({ ping: 1 });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/dist/databases/mysql/templates/connection.ts.hbs

@@ -1,14 +1,14 @@
-import mysql from 'mysql2/promise';
-
-let pool: mysql.Pool | null = null;
-
-export function getMysqlPool(): mysql.Pool {
-  if (!pool) {
-    const url = process.env.DATABASE_URL;
-    if (!url) {
-      throw new Error('DATABASE_URL is not set');
-    }
-    pool = mysql.createPool(url);
-  }
-  return pool;
-}
+import mysql from 'mysql2/promise';
+
+let pool: mysql.Pool | null = null;
+
+export function getMysqlPool(): mysql.Pool {
+  if (!pool) {
+    const url = process.env.DATABASE_URL;
+    if (!url) {
+      throw new Error('DATABASE_URL is not set');
+    }
+    pool = mysql.createPool(url);
+  }
+  return pool;
+}

package/dist/databases/mysql/templates/health-check.ts.hbs

@@ -1,12 +1,12 @@
-import { getMysqlPool } from './db-connection.js';
-
-export async function checkMysqlHealth(): Promise<boolean> {
-  try {
-    const connection = await getMysqlPool().getConnection();
-    await connection.ping();
-    connection.release();
-    return true;
-  } catch {
-    return false;
-  }
-}
+import { getMysqlPool } from './db-connection.js';
+
+export async function checkMysqlHealth(): Promise<boolean> {
+  try {
+    const connection = await getMysqlPool().getConnection();
+    await connection.ping();
+    connection.release();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/dist/databases/postgres/templates/connection.ts.hbs

@@ -1,14 +1,14 @@
-import pg from 'pg';
-
-let pool: pg.Pool | null = null;
-
-export function getPostgresPool(): pg.Pool {
-  if (!pool) {
-    const url = process.env.DATABASE_URL;
-    if (!url) {
-      throw new Error('DATABASE_URL is not set');
-    }
-    pool = new pg.Pool({ connectionString: url });
-  }
-  return pool;
-}
+import pg from 'pg';
+
+let pool: pg.Pool | null = null;
+
+export function getPostgresPool(): pg.Pool {
+  if (!pool) {
+    const url = process.env.DATABASE_URL;
+    if (!url) {
+      throw new Error('DATABASE_URL is not set');
+    }
+    pool = new pg.Pool({ connectionString: url });
+  }
+  return pool;
+}