CLI Reference

npm install -g @friendlyinternet/nuxt-crouton-collection-generator

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

# Use directly without installation
npx @friendlyinternet/nuxt-crouton-collection-generator <command>

# Or add to project devDependencies
pnpm add -D @friendlyinternet/nuxt-crouton-collection-generator
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
├── types.ts                            # TypeScript interfaces
└── nuxt.config.ts                     # Layer configuration

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

parentId: null

crouton-generate init [options]

# Create example schema
crouton-generate init

# Custom output path
crouton-generate init --output ./schemas/example.json

{
  "id": {
    "type": "string",
    "meta": {
      "primaryKey": true
    }
  },
  "name": {
    "type": "string",
    "meta": {
      "required": true,
      "maxLength": 255
    }
  },
  "description": {
    "type": "text"
  },
  "price": {
    "type": "decimal",
    "meta": {
      "precision": 10,
      "scale": 2
    }
  },
  "inStock": {
    "type": "boolean"
  },
  "createdAt": {
    "type": "date"
  }
}

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 @friendlyinternet/nuxt-crouton-events

# 3. Add to nuxt.config.ts extends
# '@friendlyinternet/nuxt-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.mjs --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 file(s)
  schemaPath: './schemas/product.json',

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

  // Target layers and collections
  targets: [
    {
      layer: 'shop',
      collections: ['products', 'categories']
    }
  ],

  // External connectors (optional)
  connectors: {},

  // 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', 'categories', 'orders']
    },
    {
      layer: 'blog',
      collections: ['posts', 'authors']
    }
  ]
}

export default {
  connectors: {
    users: {
      type: 'supersaas',      // Connector type
      autoInstall: true,       // Install package automatically
      copyFiles: true,         // Copy connector files to project
      updateAppConfig: true    // Register in app.config.ts
    },
    teams: {
      type: 'supersaas',
      autoInstall: true,
      copyFiles: true,
      updateAppConfig: true
    }
  }
}

export default {
  flags: {
    useTeamUtility: true  // Enable multi-tenancy
  }
}

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
  }
}

export default {
  connectors: {
    users: {
      type: 'supersaas',
      autoInstall: true
    }
  },
  flags: {
    autoConnectors: true  // Don't prompt, use config above
  }
}

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

  // Database
  dialect: 'pg',

  // Target layers and collections
  targets: [
    {
      layer: 'shop',
      collections: ['products', 'categories', 'orders']
    },
    {
      layer: 'blog',
      collections: ['posts', 'authors', 'tags']
    }
  ],

  // External connectors
  connectors: {
    users: {
      type: 'supersaas',
      autoInstall: true,
      copyFiles: true,
      updateAppConfig: true
    }
  },

  // Generation flags
  flags: {
    // Multi-tenancy
    useTeamUtility: true,

    // Timestamps
    useMetadata: true,

    // Relations
    autoRelations: false,

    // Translation fields
    noTranslations: false,

    // Database
    noDb: false,

    // Behavior
    force: false,
    dryRun: false,
    retries: 3,

    // Connectors
    autoConnectors: true
  }
}

{
  "authorId": {
    "type": "string",
    "refTarget": ":users",  // External reference
    "meta": {
      "required": true
    }
  }
}

✓ Analyzed 5 schemas
⚠ Found external reference: :users (used in 3 collections)

Configure connector for 'users'? (Y/n)
> Y

Which auth system?
  1. SuperSaaS (team-based)
  2. Supabase (auth.users)
  3. Clerk
  4. Skip (configure manually)
> 1

✓ Installing @friendlyinternet/nuxt-crouton-supersaas
✓ Copied app/composables/useUsers.ts
✓ Copied server/api/teams/[id]/users/index.get.ts
✓ Updated app.config.ts

export default {
  connectors: {
    users: {
      type: 'supersaas',
      autoInstall: false,  // Don't install package
      copyFiles: false,     // Don't copy files
      updateAppConfig: false  // Don't update config
    }
  },
  flags: {
    autoConnectors: true  // Use config but don't auto-setup
  }
}

# 1. Create example schema
crouton-generate init

# 2. Edit schema file
# (Edit crouton-schema.json to match your needs)

# 3. Generate collection
crouton-generate shop products --fields-file=crouton-schema.json

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

# 5. Run migrations and start dev server
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 { requireTeamAuth } from '~/server/utils/team-auth'

export default defineEventHandler(requireTeamAuth(async (event, team) => {
  // 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 @friendlyinternet/nuxt-crouton-collection-generator

# Option 2: Use npx
npx @friendlyinternet/nuxt-crouton-collection-generator <command>

# Option 3: Add to project and use npx
pnpm add -D @friendlyinternet/nuxt-crouton-collection-generator
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 @friendlyinternet/nuxt-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 ...