@compilr-dev/factory 0.1.9 → 0.1.11

package/dist/factory/registry.js

@@ -27,6 +27,10 @@ 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';
+import { reactGoToolkit } from '../toolkits/react-go/index.js';
 defaultRegistry.register(reactNodeToolkit);
 defaultRegistry.register(nextPrismaToolkit);
 defaultRegistry.register(staticLandingToolkit);
+defaultRegistry.register(reactFastapiToolkit);
+defaultRegistry.register(reactGoToolkit);

package/dist/index.d.ts

@@ -21,4 +21,6 @@ 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 { reactGoToolkit } from './toolkits/react-go/index.js';
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';

package/dist/index.js

@@ -25,5 +25,9 @@ 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';
+// React + Go Toolkit
+export { reactGoToolkit } from './toolkits/react-go/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;