CLI Reference

npm install -g @fyit/crouton-cli

crouton --help
# or
crouton-generate --help

# Use directly without installation
npx @fyit/crouton-cli <command>

# Or add to project devDependencies
pnpm add -D @fyit/crouton-cli
npx crouton-generate <command>

crouton-generate <layer> <collection> [options]

crouton-generate shop products --fields-file=./schemas/product.json

crouton-generate admin users \
  --fields-file=./schemas/user.json \
  --dialect=pg \
  --force

crouton-generate blog posts \
  --fields-file=./schemas/post.json \
  --dry-run

crouton-generate --config ./crouton.config.js

crouton-generate content pages \
  --fields-file=./schemas/page.json \
  --hierarchy

layers/[layer]/collections/[collection]/
├── app/
│   ├── components/
│   │   ├── _Form.vue                  # CRUD form with validation
│   │   ├── List.vue                   # Data table/list
│   │   └── RepeaterItem.vue           # For repeater fields (if needed)
│   └── composables/
│       └── use[Layer][Collection].ts  # Zod schema, columns, defaults (e.g., useShopProducts.ts)
├── server/
│   ├── api/teams/[id]/[collection]/
│   │   ├── index.get.ts               # GET all/by IDs
│   │   ├── index.post.ts              # CREATE
│   │   ├── [id].patch.ts              # UPDATE
│   │   └── [id].delete.ts             # DELETE
│   └── database/
│       ├── queries.ts                 # Query functions
│       ├── schema.ts                  # Drizzle schema
│       └── seed.ts                    # Seed data (with --seed flag)
├── types.ts                            # TypeScript interfaces
└── nuxt.config.ts                     # Layer configuration

parentId: z.string().nullable().optional()

parentId: null

# Generate with seed data (25 records by default)
crouton-generate shop products --fields-file=products.json --seed

# Generate with custom record count
crouton-generate shop products --fields-file=products.json --seed --count=100

// crouton.config.js
export default {
  collections: [
    { name: 'products', fieldsFile: './schemas/products.json', seed: true },           // 25 records
    { name: 'categories', fieldsFile: './schemas/categories.json', seed: { count: 50 } } // custom count
  ],
  seed: {
    defaultCount: 25,          // default for all collections
    defaultTeamId: 'seed-team' // team ID for seeded data
  },
  // ... other config
}

# Run directly
npx tsx ./layers/shop/collections/products/server/database/seed.ts

# Or import in your code
import { seedShopProducts } from './layers/shop/collections/products/server/database/seed'

await seedShopProducts({
  count: 100,
  teamId: 'my-team',
  reset: true  // optionally clear existing data first
})

crouton-generate init <name> [options]

# Create app with default settings
crouton-generate init my-app

# With features and theme
crouton-generate init my-app --features bookings,pages,editor --theme ko

# Preview without writing
crouton-generate init my-app --dry-run

crouton-generate add <feature> [options]

# Add events layer
crouton-generate add events

# Preview what will be created
crouton-generate add events --dry-run

# Overwrite existing files
crouton-generate add events --force

layers/crouton-events/
├── nuxt.config.ts                      # Layer configuration
├── types.ts                            # TypeScript interfaces
└── server/
    ├── database/
    │   ├── schema.ts                   # Drizzle schema for events table
    │   └── queries.ts                  # Query functions (getAll, create, etc.)
    └── api/teams/[id]/crouton-collection-events/
        ├── index.get.ts                # GET all events
        ├── index.post.ts               # CREATE event
        ├── [eventId].patch.ts          # UPDATE event
        └── [eventId].delete.ts         # DELETE event

# 1. Run database migration
pnpm drizzle-kit generate
pnpm drizzle-kit migrate

# 2. Install the events tracking package (for auto-tracking)
pnpm add @fyit/crouton-events

# 3. Add to nuxt.config.ts extends
# '@fyit/crouton-events'

crouton-generate config [configPath] [options]

# Auto-detect config file (searches for crouton.config.js/.mjs/.cjs/.ts)
crouton-generate config

# Use specific config file
crouton-generate config ./configs/production.config.mjs

# Generate only a single collection from config
crouton-generate config --only products

# Combine config path with --only flag
crouton-generate config ./crouton.config.js --only pages

# Alternative: Use --config flag with generate command
crouton-generate --config ./crouton.config.js

crouton-generate rollback <layer> <collection> [options]

# Preview removal
crouton-generate rollback shop products --dry-run

# Remove with confirmation
crouton-generate rollback shop products

# Force remove without prompts
crouton-generate rollback shop products --force

crouton-generate rollback-bulk [options]

# Remove entire layer
crouton-generate rollback-bulk --layer=shop

# Preview layer removal
crouton-generate rollback-bulk --layer=shop --dry-run

# Remove collections from config file
crouton-generate rollback-bulk --config=./crouton.config.js

# Force bulk removal
crouton-generate rollback-bulk --layer=shop --force

crouton-generate rollback-interactive [options]

$ crouton-generate rollback-interactive

═══════════════════════════════════════════════════════════
  INTERACTIVE ROLLBACK
═══════════════════════════════════════════════════════════

Found 3 layers:

  • shop (5 collections)
  • blog (3 collections)
  • admin (2 collections)

? What would you like to rollback?
  ❯ Entire layer (all collections)
    Specific collections
    Cancel

? Select layer:
  ❯ shop (5 collections)
    blog (3 collections)
    admin (2 collections)

? Are you sure you want to remove layer "shop"? (Y/n)

crouton-generate install

// crouton.config.js
export default {
  // Path to JSON schema files directory
  schemaPath: './schemas/',

  // Database dialect
  dialect: 'sqlite',  // or 'pg'

  // Target layers and collections
  targets: [
    {
      layer: 'shop',
      collections: [
        // Simple string for basic collections
        'products',
        // Or object with per-collection options
        {
          name: 'orders',
          fieldsFile: './schemas/order.json',
          seed: true,
          hierarchy: false
        }
      ]
    }
  ],

  // Seed configuration (optional)
  seed: {
    defaultCount: 25,
    defaultTeamId: 'seed-team'
  },

  // Generation flags
  flags: {}
}

export default {
  schemaPath: './schemas/',  // Looks for products-schema.json, etc.
  targets: [
    {
      layer: 'shop',
      collections: ['products', 'categories']  // Uses products-schema.json, categories-schema.json
    }
  ]
}

export default {
  dialect: 'pg',  // PostgreSQL
  // Or
  dialect: 'sqlite'  // SQLite (default)
}

export default {
  targets: [
    {
      layer: 'shop',
      collections: [
        'products',           // Simple: uses schemas/products-schema.json
        'categories',         // Simple: uses schemas/categories-schema.json
        {                     // With options
          name: 'orders',
          fieldsFile: './schemas/order.json',
          seed: { count: 50 },
          hierarchy: true
        }
      ]
    },
    {
      layer: 'blog',
      collections: [
        { name: 'posts', seed: true },
        { name: 'authors', seed: { count: 10 } }
      ]
    }
  ]
}

export default {
  flags: {
    useMetadata: true  // Add timestamps (default)
  }
}

export default {
  flags: {
    autoRelations: true
  }
}

export default {
  flags: {
    noTranslations: true  // Don't generate translation fields
  }
}

export default {
  flags: {
    force: true  // Overwrite files
  }
}

export default {
  flags: {
    noDb: true  // Skip database operations
  }
}

export default {
  flags: {
    dryRun: true  // Preview only
  }
}

// crouton.config.js
export default {
  // Schema location
  schemaPath: './schemas/',

  // Database
  dialect: 'sqlite',

  // Target layers and collections
  targets: [
    {
      layer: 'shop',
      collections: [
        { name: 'products', seed: true },
        { name: 'categories', seed: { count: 10 } },
        { name: 'orders', seed: { count: 100 } }
      ]
    },
    {
      layer: 'content',
      collections: [
        { name: 'pages', hierarchy: true },
        { name: 'posts', seed: true },
        'authors'  // Simple string also works
      ]
    }
  ],

  // Seed configuration
  seed: {
    defaultCount: 25,
    defaultTeamId: 'seed-team'
  },

  // Generation flags
  flags: {
    // Timestamps
    useMetadata: true,

    // Relations
    autoRelations: false,

    // Translation fields
    noTranslations: false,

    // Database
    noDb: false,

    // Behavior
    force: false,
    dryRun: false
  }
}

# 1. Scaffold a full app (runs scaffold-app → generate → doctor → summary)
crouton-generate init my-app

# 2. Customize the generated schemas and crouton.config.js

# 3. Regenerate collections if needed
crouton-generate config

# 4. Start dev server
cd my-app
pnpm dev

# 1. Create config file
cat > crouton.config.js << 'CONF'
export default {
  schemaPath: './schemas/',
  dialect: 'sqlite',
  targets: [
    {
      layer: 'shop',
      collections: ['products', 'categories', 'orders']
    }
  ],
  flags: {
    useMetadata: true,
    force: false
  }
}
CONF

# 2. Create schema files
mkdir -p schemas
# (Create products-schema.json, categories-schema.json, orders-schema.json)

# 3. Generate all at once
crouton-generate config

# 4. Export schemas
echo "export * from '~/layers/shop/collections/products/server/database/schema'" >> server/database/schema/index.ts
echo "export * from '~/layers/shop/collections/categories/server/database/schema'" >> server/database/schema/index.ts
echo "export * from '~/layers/shop/collections/orders/server/database/schema'" >> server/database/schema/index.ts

# Use --dry-run to see what would be generated
crouton-generate shop products \
  --fields-file=schemas/product.json \
  --dry-run

# Output shows:
# - Files that would be created
# - Directories that would be created
# - Schemas that would be registered

# 1. Preview removal
crouton-generate rollback shop products --dry-run

# 2. Review what will be removed

# 3. Execute removal
crouton-generate rollback shop products

# 4. Remove schema export manually from server/database/schema/index.ts

# Use interactive mode for safety
crouton-generate rollback-interactive

# Select "Entire layer"
# Select the layer to remove
# Confirm removal

// Generated: server/api/teams/[id]/products/index.get.ts
import { resolveTeamAndCheckMembership } from '@fyit/crouton-auth/server/utils/team'

export default defineEventHandler(async (event) => {
  const { team, user } = await resolveTeamAndCheckMembership(event)
  // team is automatically resolved and verified
  // All queries automatically scoped to team.id
  const products = await getProducts({ teamId: team.id })
  return products
})

{
  "publishedAt": {
    "type": "date"
  }
}

# Option 1: Install globally
npm install -g @fyit/crouton-cli

# Option 2: Use npx
npx @fyit/crouton-cli <command>

# Option 3: Add to project and use npx
pnpm add -D @fyit/crouton-cli
npx crouton-generate <command>

# Use correct path
crouton-generate config ./path/to/config.js

# Or use --config flag
crouton-generate --config ./path/to/config.js

# Or ensure default location exists
ls crouton.config.js

# Use absolute path
crouton-generate shop products --fields-file=/full/path/to/schema.json

# Or use relative path from project root
crouton-generate shop products --fields-file=./schemas/product.json

# Verify file exists
ls ./schemas/product.json

# 1. Ensure Nuxt Crouton is installed
pnpm add @fyit/crouton

# 2. Run Nuxt prepare to regenerate types
npx nuxt prepare

# 3. Run typecheck
npx nuxt typecheck

# 4. Restart TypeScript server in your editor

# Check file permissions
ls -la layers/

# Fix permissions
chmod -R u+w layers/

# Or run with sudo (not recommended)
sudo crouton-generate ...