@compilr-dev/factory 0.1.9 → 0.1.10

package/dist/factory/registry.js

@@ -27,6 +27,8 @@ export const defaultRegistry = new ToolkitRegistry();
 import { reactNodeToolkit } from '../toolkits/react-node/index.js';
 import { nextPrismaToolkit } from '../toolkits/next-prisma/index.js';
 import { staticLandingToolkit } from '../toolkits/static-landing/index.js';
+import { reactFastapiToolkit } from '../toolkits/react-fastapi/index.js';
 defaultRegistry.register(reactNodeToolkit);
 defaultRegistry.register(nextPrismaToolkit);
 defaultRegistry.register(staticLandingToolkit);
+defaultRegistry.register(reactFastapiToolkit);

package/dist/index.d.ts

@@ -21,4 +21,5 @@ export type { WriteResult } from './factory/file-writer.js';
 export { reactNodeToolkit } from './toolkits/react-node/index.js';
 export { nextPrismaToolkit } from './toolkits/next-prisma/index.js';
 export { staticLandingToolkit } from './toolkits/static-landing/index.js';
+export { reactFastapiToolkit } from './toolkits/react-fastapi/index.js';
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';

package/dist/index.js

@@ -25,5 +25,7 @@ export { reactNodeToolkit } from './toolkits/react-node/index.js';
 export { nextPrismaToolkit } from './toolkits/next-prisma/index.js';
 // Static Landing Page Toolkit
 export { staticLandingToolkit } from './toolkits/static-landing/index.js';
+// React + FastAPI Toolkit
+export { reactFastapiToolkit } from './toolkits/react-fastapi/index.js';
 // Factory skill (Phase 5)
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';

package/dist/toolkits/react-fastapi/api.d.ts

@@ -0,0 +1,9 @@
+/**
+ * React+FastAPI Toolkit — API Generator
+ *
+ * Generates: server/main.py, server/models.py,
+ * server/database/{entity}.py, server/routers/{entity}.py
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateApiFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/react-fastapi/api.js

@@ -0,0 +1,378 @@
+/**
+ * React+FastAPI Toolkit — API Generator
+ *
+ * Generates: server/main.py, server/models.py,
+ * server/database/{entity}.py, server/routers/{entity}.py
+ */
+import { toCamelCase, toKebabCase } from '../../model/naming.js';
+import { pyType, fkFieldName, belongsToRels, hasManyRels } from './helpers.js';
+import { toSnakeCase } from './helpers.js';
+import { generateSeedData } from './seed.js';
+export function generateApiFiles(model) {
+    return [
+        generateServerMain(model),
+        generateModels(model),
+        ...model.entities.flatMap((entity) => [
+            generateDatabase(model, entity),
+            generateRouter(model, entity),
+        ]),
+    ];
+}
+// =============================================================================
+// Server Entry Point
+// =============================================================================
+function generateServerMain(model) {
+    const routerImports = model.entities
+        .map((e) => {
+        const snakeName = toSnakeCase(e.pluralName);
+        return `from server.routers.${snakeName} import router as ${snakeName}_router`;
+    })
+        .join('\n');
+    const routerIncludes = model.entities
+        .map((e) => {
+        const snakeName = toSnakeCase(e.pluralName);
+        const apiRoute = '/api/' + toKebabCase(e.pluralName).toLowerCase();
+        return `app.include_router(${snakeName}_router, prefix="${apiRoute}")`;
+    })
+        .join('\n');
+    return {
+        path: 'server/main.py',
+        content: `from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+${routerImports}
+
+app = FastAPI(title="${model.identity.name}")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+${routerIncludes}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("server.main:app", host="0.0.0.0", port=8000, reload=True)
+`,
+    };
+}
+// =============================================================================
+// Pydantic Models
+// =============================================================================
+function generateModels(model) {
+    const modelBlocks = [];
+    for (const entity of model.entities) {
+        const btoRels = belongsToRels(entity);
+        // Create model (no id/timestamps)
+        const createFields = [];
+        for (const field of entity.fields) {
+            const pyT = pyType(field);
+            if (field.required) {
+                createFields.push(`    ${field.name}: ${pyT}`);
+            }
+            else {
+                createFields.push(`    ${field.name}: Optional[${pyT}] = None`);
+            }
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            createFields.push(`    ${fk}: int`);
+        }
+        // Update model (all Optional)
+        const updateFields = [];
+        for (const field of entity.fields) {
+            const pyT = pyType(field);
+            updateFields.push(`    ${field.name}: Optional[${pyT}] = None`);
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            updateFields.push(`    ${fk}: Optional[int] = None`);
+        }
+        // Response model (id + all fields + timestamps)
+        const responseFields = ['    id: int'];
+        for (const field of entity.fields) {
+            const pyT = pyType(field);
+            if (field.required) {
+                responseFields.push(`    ${field.name}: ${pyT}`);
+            }
+            else {
+                responseFields.push(`    ${field.name}: Optional[${pyT}] = None`);
+            }
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            responseFields.push(`    ${fk}: int`);
+        }
+        responseFields.push('    createdAt: str');
+        responseFields.push('    updatedAt: str');
+        modelBlocks.push(`
+class ${entity.name}Create(BaseModel):
+${createFields.join('\n')}
+
+class ${entity.name}Update(BaseModel):
+${updateFields.join('\n')}
+
+class ${entity.name}Response(BaseModel):
+${responseFields.join('\n')}
+    model_config = ConfigDict(populate_by_name=True)`);
+    }
+    return {
+        path: 'server/models.py',
+        content: `from typing import Optional
+from pydantic import BaseModel, ConfigDict
+${modelBlocks.join('\n')}
+`,
+    };
+}
+// =============================================================================
+// Database (Data Store)
+// =============================================================================
+function generateDatabase(model, entity) {
+    const snakeName = toSnakeCase(entity.pluralName);
+    // Collect searchable fields (string + enum types)
+    const searchableFields = entity.fields
+        .filter((f) => f.type === 'string' || f.type === 'enum')
+        .map((f) => `item.get("${f.name}", "")`);
+    const searchLogic = searchableFields.length > 0
+        ? `            q = search.lower()
+            result = [
+                item for item in result
+                if any(
+                    q in str(v).lower()
+                    for v in [${searchableFields.join(', ')}]
+                    if v is not None
+                )
+            ]`
+        : `            q = search.lower()
+            result = [
+                item for item in result
+                if any(
+                    q in str(v).lower()
+                    for v in item.values()
+                    if v is not None
+                )
+            ]`;
+    const seedData = generateSeedData(model, entity);
+    return {
+        path: `server/database/${snakeName}.py`,
+        content: `"""In-memory data store for ${entity.pluralName}."""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+
+${seedData}
+
+
+class DataStore:
+    def __init__(self):
+        self.items: list[dict] = [dict(item) for item in SEED_DATA]
+        self.next_id: int = len(self.items) + 1
+
+    def get_all(self) -> list[dict]:
+        return self.items
+
+    def get_by_id(self, item_id: int) -> Optional[dict]:
+        for item in self.items:
+            if item["id"] == item_id:
+                return item
+        return None
+
+    def query(
+        self,
+        search: Optional[str] = None,
+        filters: Optional[dict[str, str]] = None,
+    ) -> dict:
+        result = list(self.items)
+        if search:
+${searchLogic}
+        if filters:
+            for field, value in filters.items():
+                result = [
+                    item for item in result
+                    if str(item.get(field, "")) == value
+                ]
+        return {"data": result, "total": len(result)}
+
+    def create(self, data: dict) -> dict:
+        now = datetime.now(timezone.utc).isoformat()
+        item = {
+            **data,
+            "id": self.next_id,
+            "createdAt": now,
+            "updatedAt": now,
+        }
+        self.next_id += 1
+        self.items.append(item)
+        return item
+
+    def update(self, item_id: int, data: dict) -> Optional[dict]:
+        for i, item in enumerate(self.items):
+            if item["id"] == item_id:
+                now = datetime.now(timezone.utc).isoformat()
+                self.items[i] = {**item, **data, "id": item_id, "updatedAt": now}
+                return self.items[i]
+        return None
+
+    def remove(self, item_id: int) -> bool:
+        for i, item in enumerate(self.items):
+            if item["id"] == item_id:
+                self.items.pop(i)
+                return True
+        return False
+
+
+store = DataStore()
+`,
+    };
+}
+// =============================================================================
+// Router
+// =============================================================================
+function generateRouter(model, entity) {
+    const snakeName = toSnakeCase(entity.pluralName);
+    const btoRels = belongsToRels(entity);
+    const hmRels = hasManyRels(entity);
+    // Imports for belongsTo populate
+    const populateImports = btoRels
+        .map((rel) => {
+        const targetEntity = model.entities.find((e) => e.name === rel.target);
+        if (!targetEntity)
+            return '';
+        const targetSnake = toSnakeCase(targetEntity.pluralName);
+        return `from server.database.${targetSnake} import store as ${targetSnake}_store`;
+    })
+        .filter(Boolean)
+        .join('\n');
+    // Imports for hasMany includes
+    const hasManyImports = hmRels
+        .map((rel) => {
+        const targetEntity = model.entities.find((e) => e.name === rel.target);
+        if (!targetEntity)
+            return '';
+        const targetSnake = toSnakeCase(targetEntity.pluralName);
+        return `from server.database.${targetSnake} import store as ${targetSnake}_store`;
+    })
+        .filter(Boolean)
+        .join('\n');
+    // Deduplicate imports (if same entity appears in both belongsTo and hasMany targets)
+    const allImports = [
+        ...new Set([...populateImports.split('\n'), ...hasManyImports.split('\n')].filter(Boolean)),
+    ].join('\n');
+    // Populate function for belongsTo
+    const populateLogic = btoRels.length > 0
+        ? `
+
+def populate(item: dict) -> dict:
+    result = dict(item)
+${btoRels
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetSnake = toSnakeCase(targetEntity.pluralName);
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            return `    if result.get("${fk}"):
+        result["${targetVar}"] = ${targetSnake}_store.get_by_id(result["${fk}"])`;
+        })
+            .filter(Boolean)
+            .join('\n')}
+    return result
+`
+        : '';
+    // GET list with optional populate
+    const getListReturn = btoRels.length > 0
+        ? '    return {"data": [populate(item) for item in result["data"]], "total": result["total"]}'
+        : '    return {"data": result["data"], "total": result["total"]}';
+    // GET by ID with ?include= for hasMany
+    let getByIdBody;
+    if (hmRels.length > 0) {
+        const includeChecks = hmRels
+            .map((rel) => {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            const targetSnake = toSnakeCase(targetEntity.pluralName);
+            const fkRel = targetEntity.relationships.find((r) => r.type === 'belongsTo' && r.target === entity.name) ?? { type: 'belongsTo', target: entity.name };
+            const fk = fkFieldName(fkRel);
+            return `    if "${targetVar}" in include:
+        result["${targetVar}"] = [
+            r for r in ${targetSnake}_store.get_all()
+            if r.get("${fk}") == item["id"]
+        ]`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        const populateExpr = btoRels.length > 0 ? 'populate(item)' : 'dict(item)';
+        getByIdBody = `    item = store.get_by_id(item_id)
+    if not item:
+        raise HTTPException(status_code=404, detail="Not found")
+    include_param = request.query_params.get("include", "")
+    include = [s.strip() for s in include_param.split(",") if s.strip()]
+    result = ${populateExpr}
+${includeChecks}
+    return result`;
+    }
+    else {
+        const getByIdReturn = btoRels.length > 0 ? '    return populate(item)' : '    return item';
+        getByIdBody = `    item = store.get_by_id(item_id)
+    if not item:
+        raise HTTPException(status_code=404, detail="Not found")
+${getByIdReturn}`;
+    }
+    // Determine if we need Request import
+    const needsRequest = hmRels.length > 0;
+    return {
+        path: `server/routers/${snakeName}.py`,
+        content: `import re
+from fastapi import APIRouter, HTTPException${needsRequest ? ', Request' : ''}
+from server.models import ${entity.name}Create, ${entity.name}Update
+from server.database.${snakeName} import store
+${allImports ? allImports + '\n' : ''}
+router = APIRouter()
+${populateLogic}
+
+@router.get("/")
+def list_items(request: Request):
+    search = request.query_params.get("search")
+    filters: dict[str, str] = {}
+    for key, value in request.query_params.items():
+        match = re.match(r"^filter\\[(.+)\\]$", key)
+        if match:
+            filters[match.group(1)] = value
+    result = store.query(search=search, filters=filters if filters else None)
+${getListReturn}
+
+
+@router.get("/{item_id}")
+def get_item(item_id: int${needsRequest ? ', request: Request' : ''}):
+${getByIdBody}
+
+
+@router.post("/", status_code=201)
+def create_item(body: ${entity.name}Create):
+    return store.create(body.model_dump())
+
+
+@router.put("/{item_id}")
+def update_item(item_id: int, body: ${entity.name}Update):
+    item = store.update(item_id, {k: v for k, v in body.model_dump().items() if v is not None})
+    if not item:
+        raise HTTPException(status_code=404, detail="Not found")
+    return item
+
+
+@router.delete("/{item_id}", status_code=204)
+def delete_item(item_id: int):
+    success = store.remove(item_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Not found")
+    return None
+`,
+    };
+}

package/dist/toolkits/react-fastapi/config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * React+FastAPI Toolkit — Configuration Files Generator
+ *
+ * Generates: package.json, vite.config.ts, tailwind.config.js,
+ * tsconfig.json, postcss.config.js, requirements.txt
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateConfigFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/react-fastapi/config.js

@@ -0,0 +1,128 @@
+/**
+ * React+FastAPI Toolkit — Configuration Files Generator
+ *
+ * Generates: package.json, vite.config.ts, tailwind.config.js,
+ * tsconfig.json, postcss.config.js, requirements.txt
+ */
+import { toKebabCase } from '../../model/naming.js';
+import { generateColorShades } from '../shared/color-utils.js';
+export function generateConfigFiles(model) {
+    const appSlug = toKebabCase(model.identity.name);
+    return [
+        generatePackageJson(appSlug),
+        generateViteConfig(),
+        generateTailwindConfig(model),
+        generateTsConfig(),
+        generatePostCssConfig(),
+        generateRequirementsTxt(),
+    ];
+}
+function generatePackageJson(appSlug) {
+    const pkg = {
+        name: appSlug,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'concurrently "vite" "uvicorn server.main:app --reload --port 8000"',
+            build: 'vite build',
+            preview: 'vite preview',
+            server: 'uvicorn server.main:app --reload --port 8000',
+        },
+        dependencies: {
+            react: '^18.3.1',
+            'react-dom': '^18.3.1',
+            'react-router-dom': '^6.28.0',
+        },
+        devDependencies: {
+            '@types/react': '^18.3.12',
+            '@types/react-dom': '^18.3.1',
+            '@vitejs/plugin-react': '^4.3.4',
+            autoprefixer: '^10.4.20',
+            concurrently: '^9.1.0',
+            postcss: '^8.4.49',
+            '@tailwindcss/forms': '^0.5.9',
+            tailwindcss: '^3.4.15',
+            typescript: '^5.6.3',
+            vite: '^6.0.0',
+        },
+    };
+    return { path: 'package.json', content: JSON.stringify(pkg, null, 2) + '\n' };
+}
+function generateViteConfig() {
+    return {
+        path: 'vite.config.ts',
+        content: `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    proxy: {
+      '/api': 'http://localhost:8000',
+    },
+  },
+});
+`,
+    };
+}
+function generateTailwindConfig(model) {
+    return {
+        path: 'tailwind.config.js',
+        content: `import forms from '@tailwindcss/forms';
+
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ['./index.html', './src/**/*.{ts,tsx}'],
+  darkMode: 'class',
+  theme: {
+    extend: {
+      colors: {
+        primary: ${generateColorShades(model.theme.primaryColor)},
+      },
+    },
+  },
+  plugins: [forms],
+};
+`,
+    };
+}
+function generateTsConfig() {
+    const config = {
+        compilerOptions: {
+            target: 'ES2022',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            jsx: 'react-jsx',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            forceConsistentCasingInFileNames: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+        },
+        include: ['src'],
+    };
+    return { path: 'tsconfig.json', content: JSON.stringify(config, null, 2) + '\n' };
+}
+function generatePostCssConfig() {
+    return {
+        path: 'postcss.config.js',
+        content: `export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};
+`,
+    };
+}
+function generateRequirementsTxt() {
+    return {
+        path: 'requirements.txt',
+        content: `fastapi>=0.115.0
+uvicorn[standard]>=0.32.0
+`,
+    };
+}

package/dist/toolkits/react-fastapi/helpers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * React+FastAPI Toolkit — Helpers
+ *
+ * Python-specific helpers plus re-exports from shared helpers.
+ */
+import type { Field } from '../../model/types.js';
+/** Map a model FieldType to a Python type string. */
+export declare function pyType(field: Field): string;
+/** Generate a Python default value string for a field. */
+export declare function pyDefault(field: Field): string;
+/** Convert PascalCase or camelCase to snake_case. */
+export declare function toSnakeCase(name: string): string;
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-fastapi/helpers.js

@@ -0,0 +1,54 @@
+/**
+ * React+FastAPI Toolkit — Helpers
+ *
+ * Python-specific helpers plus re-exports from shared helpers.
+ */
+/** Map a model FieldType to a Python type string. */
+export function pyType(field) {
+    const lowerName = field.name.toLowerCase();
+    switch (field.type) {
+        case 'string':
+        case 'enum':
+        case 'date':
+            return 'str';
+        case 'number':
+            if (lowerName.includes('price') ||
+                lowerName.includes('cost') ||
+                lowerName.includes('amount')) {
+                return 'float';
+            }
+            return 'int';
+        case 'boolean':
+            return 'bool';
+        default:
+            return 'str';
+    }
+}
+/** Generate a Python default value string for a field. */
+export function pyDefault(field) {
+    if (!field.required)
+        return 'None';
+    switch (field.type) {
+        case 'string':
+        case 'date':
+            return "''";
+        case 'enum': {
+            const values = field.enumValues ?? [];
+            return values.length > 0 ? `'${values[0]}'` : "''";
+        }
+        case 'number':
+            return '0';
+        case 'boolean':
+            return 'False';
+        default:
+            return "''";
+    }
+}
+/** Convert PascalCase or camelCase to snake_case. */
+export function toSnakeCase(name) {
+    return name
+        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
+        .toLowerCase();
+}
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-fastapi/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React+FastAPI Toolkit
+ *
+ * Generates a full-stack MVP: React 18 + Vite + Tailwind + FastAPI (Python).
+ * Deterministic: same ApplicationModel -> same output files.
+ *
+ * Frontend is identical to react-node (same React components, Vite config, Tailwind).
+ * Backend is Python FastAPI with in-memory data stores.
+ */
+import type { FactoryToolkit } from '../types.js';
+export declare const reactFastapiToolkit: FactoryToolkit;

package/dist/toolkits/react-fastapi/index.js

@@ -0,0 +1,55 @@
+/**
+ * React+FastAPI Toolkit
+ *
+ * Generates a full-stack MVP: React 18 + Vite + Tailwind + FastAPI (Python).
+ * Deterministic: same ApplicationModel -> same output files.
+ *
+ * Frontend is identical to react-node (same React components, Vite config, Tailwind).
+ * Backend is Python FastAPI with in-memory data stores.
+ */
+import { generateConfigFiles } from './config.js';
+import { generateStaticFiles } from './static.js';
+import { generateShellFiles } from '../react-node/shell.js';
+import { generateSharedComponents } from './shared.js';
+import { generateDashboard } from '../react-node/dashboard.js';
+import { generateEntityFiles } from '../react-node/entity.js';
+import { generateRouter } from '../react-node/router.js';
+import { generateApiFiles } from './api.js';
+import { generateTypesFile } from '../react-node/types-gen.js';
+export const reactFastapiToolkit = {
+    id: 'react-fastapi',
+    name: 'React + FastAPI',
+    description: 'React 18 + Vite + Tailwind CSS + FastAPI — full-stack MVP with Python backend',
+    requiredSections: ['identity', 'entities', 'layout', 'features', 'theme'],
+    generate(model) {
+        const warnings = [];
+        const allFiles = [];
+        // Collect files from all generators
+        const generators = [
+            generateConfigFiles(model),
+            generateStaticFiles(model),
+            generateTypesFile(model),
+            generateShellFiles(model),
+            generateSharedComponents(),
+            generateDashboard(model),
+            generateEntityFiles(model),
+            generateRouter(model),
+            generateApiFiles(model),
+        ];
+        for (const files of generators) {
+            allFiles.push(...files);
+        }
+        // Check for potential issues
+        if (model.entities.length === 0) {
+            warnings.push('No entities defined — generated app will have minimal functionality.');
+        }
+        if (model.entities.length > 10) {
+            warnings.push('Large number of entities — generated sidebar may be crowded.');
+        }
+        return {
+            files: allFiles,
+            toolkit: 'react-fastapi',
+            warnings,
+        };
+    },
+};

package/dist/toolkits/react-fastapi/seed.d.ts

@@ -0,0 +1,12 @@
+/**
+ * React+FastAPI Toolkit — Seed Data Generator
+ *
+ * Generates realistic mock data in Python dict format.
+ * Uses shared generateFieldValue for deterministic values,
+ * wraps them in Python list-of-dicts format for FastAPI data stores.
+ */
+import type { ApplicationModel, Entity } from '../../model/types.js';
+import { SEED_COUNT } from '../shared/seed-data.js';
+/** Generate seed data items for a single entity (Python list format). */
+export declare function generateSeedData(model: ApplicationModel, entity: Entity): string;
+export { SEED_COUNT };

package/dist/toolkits/react-fastapi/seed.js

@@ -0,0 +1,54 @@
+/**
+ * React+FastAPI Toolkit — Seed Data Generator
+ *
+ * Generates realistic mock data in Python dict format.
+ * Uses shared generateFieldValue for deterministic values,
+ * wraps them in Python list-of-dicts format for FastAPI data stores.
+ */
+import { belongsToRels, fkFieldName } from './helpers.js';
+import { generateFieldValue, SEED_COUNT } from '../shared/seed-data.js';
+/** Generate seed data items for a single entity (Python list format). */
+export function generateSeedData(model, entity) {
+    const rels = belongsToRels(entity);
+    const lines = [];
+    lines.push('SEED_DATA = [');
+    for (let i = 0; i < SEED_COUNT; i++) {
+        lines.push('    {');
+        lines.push(`        "id": ${String(i + 1)},`);
+        for (const field of entity.fields) {
+            const jsValue = generateFieldValue(field, i, entity.name);
+            const pyValue = jsToPyValue(jsValue, field.type);
+            lines.push(`        "${field.name}": ${pyValue},`);
+        }
+        // FK fields from belongsTo relationships
+        for (const rel of rels) {
+            const fk = fkFieldName(rel);
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            const targetCount = targetEntity ? SEED_COUNT : SEED_COUNT;
+            lines.push(`        "${fk}": ${String((i % targetCount) + 1)},`);
+        }
+        // Implicit timestamps (deterministic)
+        const createdDate = new Date('2025-06-01T10:00:00Z');
+        createdDate.setDate(createdDate.getDate() + i * 2);
+        const updatedDate = new Date(createdDate);
+        updatedDate.setDate(updatedDate.getDate() + i);
+        lines.push(`        "createdAt": "${createdDate.toISOString()}",`);
+        lines.push(`        "updatedAt": "${updatedDate.toISOString()}",`);
+        lines.push('    },');
+    }
+    lines.push(']');
+    return lines.join('\n');
+}
+/** Convert a JS seed value string to Python format. */
+function jsToPyValue(jsValue, fieldType) {
+    if (fieldType === 'boolean') {
+        return jsValue === 'true' ? 'True' : 'False';
+    }
+    // String/enum/date values come wrapped in single quotes — convert to double quotes
+    if (jsValue.startsWith("'") && jsValue.endsWith("'")) {
+        return `"${jsValue.slice(1, -1)}"`;
+    }
+    // Numbers pass through unchanged
+    return jsValue;
+}
+export { SEED_COUNT };

package/dist/toolkits/react-fastapi/shared.d.ts

@@ -0,0 +1,6 @@
+/**
+ * React+FastAPI Toolkit — Shared Components Generator
+ *
+ * Re-exports from the shared components module.
+ */
+export { generateSharedComponents } from '../shared/components.js';

package/dist/toolkits/react-fastapi/shared.js

@@ -0,0 +1,6 @@
+/**
+ * React+FastAPI Toolkit — Shared Components Generator
+ *
+ * Re-exports from the shared components module.
+ */
+export { generateSharedComponents } from '../shared/components.js';

package/dist/toolkits/react-fastapi/static.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React+FastAPI Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, .env.example, README.md, index.html, src/main.tsx, src/index.css
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateStaticFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/react-fastapi/static.js

@@ -0,0 +1,123 @@
+/**
+ * React+FastAPI Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, .env.example, README.md, index.html, src/main.tsx, src/index.css
+ */
+export function generateStaticFiles(model) {
+    return [
+        generateGitignore(),
+        generateEnvExample(),
+        generateReadme(model),
+        generateIndexHtml(model),
+        generateMainTsx(),
+        generateIndexCss(),
+    ];
+}
+function generateGitignore() {
+    return {
+        path: '.gitignore',
+        content: `node_modules
+dist
+.env
+*.local
+__pycache__
+.venv
+*.pyc
+`,
+    };
+}
+function generateEnvExample() {
+    return {
+        path: '.env.example',
+        content: `PORT=8000
+VITE_API_URL=http://localhost:8000
+`,
+    };
+}
+function generateReadme(model) {
+    let entitiesSection = '';
+    if (model.entities.length > 0) {
+        const entityLines = model.entities
+            .map((e) => {
+            const relCount = e.relationships.length;
+            const parts = [`${String(e.fields.length)} fields`];
+            if (relCount > 0) {
+                parts.push(`${String(relCount)} relationship${relCount > 1 ? 's' : ''}`);
+            }
+            return `- **${e.name}** (${e.icon}) — ${parts.join(', ')}`;
+        })
+            .join('\n');
+        entitiesSection = `\n## Entities\n\n${entityLines}\n`;
+    }
+    return {
+        path: 'README.md',
+        content: `# ${model.identity.name}
+
+${model.identity.description}
+${entitiesSection}
+## Getting Started
+
+\`\`\`bash
+npm install
+pip install -r requirements.txt
+npm run dev
+\`\`\`
+
+This starts both the Vite dev server and the FastAPI server.
+
+- **Frontend:** http://localhost:5173
+- **API:** http://localhost:8000
+
+## Tech Stack
+
+- React 18 + TypeScript
+- Vite
+- Tailwind CSS
+- FastAPI (Python)
+- React Router v6
+`,
+    };
+}
+function generateIndexHtml(model) {
+    return {
+        path: 'index.html',
+        content: `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${model.identity.name}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`,
+    };
+}
+function generateMainTsx() {
+    return {
+        path: 'src/main.tsx',
+        content: `import React from 'react';
+import ReactDOM from 'react-dom/client';
+import App from './App';
+import './index.css';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);
+`,
+    };
+}
+function generateIndexCss() {
+    return {
+        path: 'src/index.css',
+        content: `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/factory",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "AI-driven application scaffolder for the compilr-dev ecosystem",
   "type": "module",
   "main": "dist/index.js",