@compilr-dev/factory 0.1.9 → 0.1.11

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

@@ -0,0 +1,523 @@
+/**
+ * React+Go Toolkit — API Generator
+ *
+ * Generates: server/main.go, server/models.go,
+ * server/data/{entity}.go, server/handlers/{entity}.go
+ *
+ * All files use `package main` so `go run ./server` compiles everything.
+ * Go 1.22+ net/http stdlib with method-based routing.
+ */
+import { toCamelCase, toKebabCase, toPascalCase } from '../../model/naming.js';
+import { goType, 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) => [
+            generateDataStore(model, entity),
+            generateHandlers(model, entity),
+        ]),
+    ];
+}
+// =============================================================================
+// Server Entry Point — server/main.go
+// =============================================================================
+function generateServerMain(model) {
+    const handlerRegistrations = model.entities
+        .map((e) => `\tRegister${e.name}Handlers(mux)`)
+        .join('\n');
+    return {
+        path: 'server/main.go',
+        content: `package main
+
+import (
+\t"fmt"
+\t"log"
+\t"net/http"
+\t"os"
+)
+
+func corsMiddleware(next http.Handler) http.Handler {
+\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+\t\tw.Header().Set("Access-Control-Allow-Origin", "*")
+\t\tw.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+\t\tw.Header().Set("Access-Control-Allow-Headers", "Content-Type")
+\t\tif r.Method == http.MethodOptions {
+\t\t\tw.WriteHeader(http.StatusNoContent)
+\t\t\treturn
+\t\t}
+\t\tnext.ServeHTTP(w, r)
+\t})
+}
+
+func main() {
+\tmux := http.NewServeMux()
+
+${handlerRegistrations}
+
+\tport := os.Getenv("PORT")
+\tif port == "" {
+\t\tport = "8080"
+\t}
+
+\tfmt.Printf("Server listening on :%s\\n", port)
+\tlog.Fatal(http.ListenAndServe(":"+port, corsMiddleware(mux)))
+}
+`,
+    };
+}
+// =============================================================================
+// Models — server/models.go
+// =============================================================================
+function generateModels(model) {
+    const modelBlocks = [];
+    for (const entity of model.entities) {
+        const btoRels = belongsToRels(entity);
+        // Main struct (with json tags)
+        const structFields = [];
+        structFields.push(`\tID        int    \`json:"id"\``);
+        for (const field of entity.fields) {
+            const goT = goType(field);
+            const jsonTag = field.name;
+            const goFieldName = toPascalCase(field.name);
+            structFields.push(`\t${goFieldName} ${goT} \`json:"${jsonTag}"\``);
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            const goFieldName = toPascalCase(fk);
+            structFields.push(`\t${goFieldName} int \`json:"${fk}"\``);
+        }
+        structFields.push(`\tCreatedAt string \`json:"createdAt"\``);
+        structFields.push(`\tUpdatedAt string \`json:"updatedAt"\``);
+        // Input struct (for create/update — pointer fields for optional update detection)
+        const inputFields = [];
+        for (const field of entity.fields) {
+            const goT = goType(field);
+            const jsonTag = field.name;
+            const goFieldName = toPascalCase(field.name);
+            inputFields.push(`\t${goFieldName} *${goT} \`json:"${jsonTag}"\``);
+        }
+        for (const rel of btoRels) {
+            const fk = fkFieldName(rel);
+            const goFieldName = toPascalCase(fk);
+            inputFields.push(`\t${goFieldName} *int \`json:"${fk}"\``);
+        }
+        modelBlocks.push(`type ${entity.name} struct {
+${structFields.join('\n')}
+}
+
+type ${entity.name}Input struct {
+${inputFields.join('\n')}
+}`);
+    }
+    return {
+        path: 'server/models.go',
+        content: `package main
+${modelBlocks.length > 0 ? '\n' + modelBlocks.join('\n\n') + '\n' : ''}`,
+    };
+}
+// =============================================================================
+// Data Store — server/data/{entity}.go
+// =============================================================================
+function generateDataStore(model, entity) {
+    const lowerName = toCamelCase(entity.pluralName);
+    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) => toPascalCase(f.name));
+    let searchLogic;
+    if (searchableFields.length > 0) {
+        const fieldChecks = searchableFields
+            .map((f) => `\t\t\t\tstrings.Contains(strings.ToLower(fmt.Sprintf("%v", item.${f})), q)`)
+            .join(' ||\n');
+        searchLogic = `\t\tq := strings.ToLower(search)
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tif ${fieldChecks.trim()} {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered`;
+    }
+    else {
+        searchLogic = `\t\tq := strings.ToLower(search)
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tif strings.Contains(strings.ToLower(fmt.Sprintf("%v", item)), q) {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered`;
+    }
+    // Filter logic — check field values via reflect-like approach (simple string comparison)
+    const filterableFields = entity.fields.map((f) => ({
+        jsonName: f.name,
+        goName: toPascalCase(f.name),
+    }));
+    const filterChecks = filterableFields
+        .map((f) => `\t\t\t\tcase "${f.jsonName}":\n\t\t\t\t\tif fmt.Sprintf("%v", item.${f.goName}) != value {\n\t\t\t\t\t\tmatch = false\n\t\t\t\t\t}`)
+        .join('\n');
+    const seedData = generateSeedData(model, entity);
+    return {
+        path: `server/data/${snakeName}.go`,
+        content: `package main
+
+import (
+\t"fmt"
+\t"strings"
+\t"sync"
+\t"time"
+)
+
+${seedData}
+
+type ${entity.name}Store struct {
+\tmu     sync.Mutex
+\titems  []${entity.name}
+\tnextID int
+}
+
+var ${lowerName}Store = &${entity.name}Store{
+\titems:  make([]${entity.name}, len(seedData)),
+\tnextID: len(seedData) + 1,
+}
+
+func init() {
+\tcopy(${lowerName}Store.items, seedData)
+}
+
+func (s *${entity.name}Store) GetAll() []${entity.name} {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tresult := make([]${entity.name}, len(s.items))
+\tcopy(result, s.items)
+\treturn result
+}
+
+func (s *${entity.name}Store) GetByID(id int) (${entity.name}, bool) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor _, item := range s.items {
+\t\tif item.ID == id {
+\t\t\treturn item, true
+\t\t}
+\t}
+\treturn ${entity.name}{}, false
+}
+
+func (s *${entity.name}Store) Query(search string, filters map[string]string) ([]${entity.name}, int) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tresult := make([]${entity.name}, len(s.items))
+\tcopy(result, s.items)
+
+\tif search != "" {
+${searchLogic}
+\t}
+
+\tif len(filters) > 0 {
+\t\tvar filtered []${entity.name}
+\t\tfor _, item := range result {
+\t\t\tmatch := true
+\t\t\tfor field, value := range filters {
+\t\t\t\tswitch field {
+${filterChecks}
+\t\t\t\t}
+\t\t\t}
+\t\t\tif match {
+\t\t\t\tfiltered = append(filtered, item)
+\t\t\t}
+\t\t}
+\t\tresult = filtered
+\t}
+
+\treturn result, len(result)
+}
+
+func (s *${entity.name}Store) Create(input ${entity.name}Input) ${entity.name} {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tnow := time.Now().UTC().Format(time.RFC3339)
+\titem := ${entity.name}{
+\t\tID:        s.nextID,
+\t\tCreatedAt: now,
+\t\tUpdatedAt: now,
+\t}
+\ts.nextID++
+${entity.fields.map((f) => `\tif input.${toPascalCase(f.name)} != nil {\n\t\titem.${toPascalCase(f.name)} = *input.${toPascalCase(f.name)}\n\t}`).join('\n')}
+${belongsToRels(entity)
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            return `\tif input.${goField} != nil {\n\t\titem.${goField} = *input.${goField}\n\t}`;
+        })
+            .join('\n')}
+\ts.items = append(s.items, item)
+\treturn item
+}
+
+func (s *${entity.name}Store) Update(id int, input ${entity.name}Input) (${entity.name}, bool) {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor i, item := range s.items {
+\t\tif item.ID == id {
+\t\t\tnow := time.Now().UTC().Format(time.RFC3339)
+${entity.fields.map((f) => `\t\t\tif input.${toPascalCase(f.name)} != nil {\n\t\t\t\ts.items[i].${toPascalCase(f.name)} = *input.${toPascalCase(f.name)}\n\t\t\t}`).join('\n')}
+${belongsToRels(entity)
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            return `\t\t\tif input.${goField} != nil {\n\t\t\t\ts.items[i].${goField} = *input.${goField}\n\t\t\t}`;
+        })
+            .join('\n')}
+\t\t\ts.items[i].UpdatedAt = now
+\t\t\treturn s.items[i], true
+\t\t}
+\t}
+\treturn ${entity.name}{}, false
+}
+
+func (s *${entity.name}Store) Remove(id int) bool {
+\ts.mu.Lock()
+\tdefer s.mu.Unlock()
+\tfor i, item := range s.items {
+\t\tif item.ID == id {
+\t\t\ts.items = append(s.items[:i], s.items[i+1:]...)
+\t\t\treturn true
+\t\t}
+\t}
+\treturn false
+}
+`,
+    };
+}
+// =============================================================================
+// Handlers — server/handlers/{entity}.go
+// =============================================================================
+function generateHandlers(model, entity) {
+    const snakeName = toSnakeCase(entity.pluralName);
+    const lowerName = toCamelCase(entity.pluralName);
+    const apiRoute = '/api/' + toKebabCase(entity.pluralName).toLowerCase();
+    const btoRels = belongsToRels(entity);
+    const hmRels = hasManyRels(entity);
+    // Populate function for belongsTo
+    let populateType = '';
+    let populateFunc = '';
+    if (btoRels.length > 0) {
+        const populateFields = [];
+        // Original entity fields
+        populateFields.push(`\t${entity.name}`);
+        for (const rel of btoRels) {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                continue;
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            populateFields.push(`\t${toPascalCase(targetVar)} *${rel.target} \`json:"${targetVar}"\``);
+        }
+        populateType = `\ntype ${entity.name}WithRels struct {
+${populateFields.join('\n')}
+}\n`;
+        const populateBody = btoRels
+            .map((rel) => {
+            const fk = fkFieldName(rel);
+            const goField = toPascalCase(fk);
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = rel.target.charAt(0).toLowerCase() + rel.target.slice(1);
+            const targetStoreName = toCamelCase(targetEntity.pluralName);
+            return `\tif item.${goField} != 0 {
+\t\tif found, ok := ${targetStoreName}Store.GetByID(item.${goField}); ok {
+\t\t\tresult.${toPascalCase(targetVar)} = &found
+\t\t}
+\t}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        populateFunc = `
+func populate${entity.name}(item ${entity.name}) ${entity.name}WithRels {
+\tresult := ${entity.name}WithRels{${entity.name}: item}
+${populateBody}
+\treturn result
+}
+`;
+    }
+    // hasMany include logic
+    let includeLogic = '';
+    let includeType = '';
+    if (hmRels.length > 0) {
+        const includeFields = [];
+        if (btoRels.length > 0) {
+            includeFields.push(`\t${entity.name}WithRels`);
+        }
+        else {
+            includeFields.push(`\t${entity.name}`);
+        }
+        for (const rel of hmRels) {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                continue;
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            includeFields.push(`\t${toPascalCase(targetVar)} []${rel.target} \`json:"${targetVar},omitempty"\``);
+        }
+        includeType = `\ntype ${entity.name}WithIncludes struct {
+${includeFields.join('\n')}
+}\n`;
+        const includeChecks = hmRels
+            .map((rel) => {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            const targetStoreName = toCamelCase(targetEntity.pluralName);
+            const fkRel = targetEntity.relationships.find((r) => r.type === 'belongsTo' && r.target === entity.name) ?? { type: 'belongsTo', target: entity.name };
+            const fk = fkFieldName(fkRel);
+            const goFk = toPascalCase(fk);
+            return `\t\tfor _, inc := range includes {
+\t\t\tif inc == "${targetVar}" {
+\t\t\t\tallItems := ${targetStoreName}Store.GetAll()
+\t\t\t\tvar related []${rel.target}
+\t\t\t\tfor _, r := range allItems {
+\t\t\t\t\tif r.${goFk} == item.ID {
+\t\t\t\t\t\trelated = append(related, r)
+\t\t\t\t\t}
+\t\t\t\t}
+\t\t\t\tresult.${toPascalCase(targetVar)} = related
+\t\t\t}
+\t\t}`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        includeLogic = includeChecks;
+    }
+    // GET list handler
+    const listReturnExpr = btoRels.length > 0
+        ? `\tpopulated := make([]${entity.name}WithRels, len(items))
+\tfor i, item := range items {
+\t\tpopulated[i] = populate${entity.name}(item)
+\t}
+\tjson.NewEncoder(w).Encode(map[string]any{"data": populated, "total": total})`
+        : `\tjson.NewEncoder(w).Encode(map[string]any{"data": items, "total": total})`;
+    // GET by ID handler
+    let getByIDBody;
+    if (hmRels.length > 0) {
+        const baseExpr = btoRels.length > 0 ? `populate${entity.name}(item)` : `item`;
+        const innerType = btoRels.length > 0 ? `${entity.name}WithRels` : entity.name;
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tincludeParam := r.URL.Query().Get("include")
+\tincludes := strings.Split(includeParam, ",")
+\tresult := ${entity.name}WithIncludes{${innerType}: ${baseExpr}}
+${includeLogic}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(result)`;
+    }
+    else if (btoRels.length > 0) {
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(populate${entity.name}(item))`;
+    }
+    else {
+        getByIDBody = `\titem, ok := ${lowerName}Store.GetByID(id)
+\tif !ok {
+\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\treturn
+\t}
+\tw.Header().Set("Content-Type", "application/json")
+\tjson.NewEncoder(w).Encode(item)`;
+    }
+    // Determine imports needed
+    const needsStrings = hmRels.length > 0;
+    return {
+        path: `server/handlers/${snakeName}.go`,
+        content: `package main
+
+import (
+\t"encoding/json"
+\t"net/http"
+\t"strconv"${needsStrings ? '\n\t"strings"' : ''}
+)
+${populateType}${includeType}${populateFunc}
+func Register${entity.name}Handlers(mux *http.ServeMux) {
+\tmux.HandleFunc("GET ${apiRoute}", func(w http.ResponseWriter, r *http.Request) {
+\t\tsearch := r.URL.Query().Get("search")
+\t\tfilters := make(map[string]string)
+\t\tfor key, values := range r.URL.Query() {
+\t\t\tif len(key) > 7 && key[:7] == "filter[" && key[len(key)-1] == ']' {
+\t\t\t\tfield := key[7 : len(key)-1]
+\t\t\t\tfilters[field] = values[0]
+\t\t\t}
+\t\t}
+\t\titems, total := ${lowerName}Store.Query(search, filters)
+\t\tw.Header().Set("Content-Type", "application/json")
+${listReturnExpr}
+\t})
+
+\tmux.HandleFunc("GET ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+${getByIDBody}
+\t})
+
+\tmux.HandleFunc("POST ${apiRoute}", func(w http.ResponseWriter, r *http.Request) {
+\t\tvar input ${entity.name}Input
+\t\tif err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid json"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\titem := ${lowerName}Store.Create(input)
+\t\tw.Header().Set("Content-Type", "application/json")
+\t\tw.WriteHeader(http.StatusCreated)
+\t\tjson.NewEncoder(w).Encode(item)
+\t})
+
+\tmux.HandleFunc("PUT ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\tvar input ${entity.name}Input
+\t\tif err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid json"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\titem, ok := ${lowerName}Store.Update(id, input)
+\t\tif !ok {
+\t\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\t\treturn
+\t\t}
+\t\tw.Header().Set("Content-Type", "application/json")
+\t\tjson.NewEncoder(w).Encode(item)
+\t})
+
+\tmux.HandleFunc("DELETE ${apiRoute}/{id}", func(w http.ResponseWriter, r *http.Request) {
+\t\tid, err := strconv.Atoi(r.PathValue("id"))
+\t\tif err != nil {
+\t\t\thttp.Error(w, \`{"error":"invalid id"}\`, http.StatusBadRequest)
+\t\t\treturn
+\t\t}
+\t\tok := ${lowerName}Store.Remove(id)
+\t\tif !ok {
+\t\t\thttp.Error(w, \`{"error":"not found"}\`, http.StatusNotFound)
+\t\t\treturn
+\t\t}
+\t\tw.WriteHeader(http.StatusNoContent)
+\t})
+}
+`,
+    };
+}

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

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

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

@@ -0,0 +1,129 @@
+/**
+ * React+Go Toolkit — Configuration Files Generator
+ *
+ * Generates: package.json, vite.config.ts, tailwind.config.js,
+ * tsconfig.json, postcss.config.js, go.mod
+ */
+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(),
+        generateGoMod(appSlug),
+    ];
+}
+function generatePackageJson(appSlug) {
+    const pkg = {
+        name: appSlug,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'concurrently "vite" "go run ./server"',
+            build: 'vite build',
+            preview: 'vite preview',
+            server: 'go run ./server',
+        },
+        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:8080',
+    },
+  },
+});
+`,
+    };
+}
+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 generateGoMod(appSlug) {
+    return {
+        path: 'go.mod',
+        content: `module ${appSlug}
+
+go 1.22
+`,
+    };
+}

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

@@ -0,0 +1,13 @@
+/**
+ * React+Go Toolkit — Helpers
+ *
+ * Go-specific helpers plus re-exports from shared helpers.
+ */
+import type { Field } from '../../model/types.js';
+/** Map a model FieldType to a Go type string. */
+export declare function goType(field: Field): string;
+/** Generate a Go zero value string for a field. */
+export declare function goZeroValue(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';