Baasix CLI

# Global installation (recommended)
npm install -g baasix

# Or use npx without installation
npx baasix <command>

# Interactive mode
baasix init

# With options
baasix init --name my-app --template api

# Skip prompts with defaults
baasix init --template api -y

my-api/
├── server.js          # Entry point
├── package.json       # Dependencies
├── .env               # Configuration
├── .env.example       # Example configuration
├── extensions/        # Custom hooks & endpoints
├── migrations/        # Database migrations
└── uploads/           # File uploads

my-frontend/
├── src/
│   ├── app/           # Next.js App Router pages
│   │   ├── layout.tsx
│   │   ├── page.tsx
│   │   └── globals.css
│   └── lib/
│       └── baasix.ts  # Pre-configured SDK client
├── package.json
├── .env.local         # NEXT_PUBLIC_BAASIX_URL only
└── README.md

my-frontend/
├── pages/             # Next.js pages
│   ├── _app.tsx
│   └── index.tsx
├── lib/
│   └── baasix.ts      # Pre-configured SDK client
├── styles/
│   └── globals.css
├── package.json
└── .env.local

$ npx baasix init --template api my-api

┌  Baasix Project Setup
│
◇  Project structure created
│
◇  Dependencies installed
│
└  ✨ Project created successfully!

Next steps:
  cd my-api
  # Review and update your .env file
  npm run dev

# Generate types from running Baasix instance
baasix generate

# With custom options
baasix generate --url http://localhost:8056 --output ./src/types/baasix.d.ts -y

// System collections (referenced by relations)
export interface BaasixUser {
  id: string;
  firstName: string;
  lastName?: string | null;
  email?: string | null;
  role_Id: string;
  role?: BaasixRole | null;
}

export interface BaasixRole {
  id: string;
  name: string;
  description?: string | null;
}

export interface BaasixFile {
  id: string;
  filename: string;
  type: string;
  size: number;
}

// Your collections with proper relation types
export interface Product {
  id: string;
  name: string;
  price: number;
  status: 'published' | 'draft' | 'archived';  // Enum as union type
  category_Id?: string | null;
  category?: Category | null;                   // M2O relation
  userCreated_Id?: string | null;
  userCreated?: BaasixUser | null;             // System relation
  image_Id?: string | null;
  image?: BaasixFile | null;                   // File relation
  createdAt?: string;
  updatedAt?: string;
}

export interface Category {
  id: string;
  name: string;
  products?: Product[] | null;  // O2M relation (HasMany)
}

// Collection name union
export type CollectionName = "products" | "categories";

// Type map for generic helpers
export interface CollectionTypeMap {
  products: Product;
  categories: Category;
}

import { createBaasix } from '@tspvivek/baasix-sdk';
import type { Product, Category, BaasixUser } from './types/baasix';

const baasix = createBaasix({
  url: 'http://localhost:8056',
});

// Fully typed queries
const { data: products } = await baasix.items<Product>('products').find({
  filter: { status: { eq: 'published' } },  // Autocomplete for enum values
  fields: ['*', 'category.*', 'userCreated.*'],
});

// products[0].category is typed as Category | null
// products[0].status is typed as 'published' | 'draft' | 'archived'
// products[0].userCreated is typed as BaasixUser | null

# Interactive mode
baasix extension

# With options
baasix extension --type hook --name order-notifications --collection orders

baasix extension --type hook --name audit-log --collection orders

// extensions/baasix-hook-audit-log/index.js
export default (hooksService, context) => {
  const { ItemsService } = context;

  // Before create hook - modify data before saving
  hooksService.registerHook('orders', 'items.create', async ({ data, accountability }) => {
    data.status = 'pending';
    data.created_by = accountability?.user?.id;
    return { data };
  });

  // After create hook - trigger side effects
  hooksService.registerHook('orders', 'items.create', async ({ data, result, accountability }) => {
    // Send notification, log audit, etc.
    console.log(`Order ${result.id} created by ${accountability?.user?.email}`);
  });

  // Before update hook
  hooksService.registerHook('orders', 'items.update', async ({ id, data, accountability }) => {
    data.updated_by = accountability?.user?.id;
    return { id, data };
  });

  // Before delete hook
  hooksService.registerHook('orders', 'items.delete', async ({ id, accountability }) => {
    console.log(`Deleting order ${id}`);
    return { id };
  });
};

baasix extension --type endpoint --name analytics

// extensions/baasix-endpoint-analytics/index.js
import { APIError } from '@tspvivek/baasix';

export default {
  id: 'analytics',
  handler: (app, context) => {
    const { ItemsService } = context;

    // GET endpoint
    app.get('/analytics/dashboard', async (req, res) => {
      if (!req.accountability?.user) {
        throw new APIError('Unauthorized', 401);
      }

      const { user, role } = req.accountability;
      
      res.json({
        message: 'Dashboard data',
        user: { id: user.id, email: user.email },
        timestamp: new Date().toISOString(),
      });
    });

    // POST endpoint with body
    app.post('/analytics/report', async (req, res) => {
      if (!req.accountability?.user) {
        throw new APIError('Unauthorized', 401);
      }

      const { startDate, endDate, metrics } = req.body;
      
      // Your analytics logic here
      res.status(201).json({ 
        message: 'Report generated',
        data: { startDate, endDate, metrics }
      });
    });

    // Parameterized endpoint
    app.get('/analytics/:type/:id', async (req, res) => {
      const { type, id } = req.params;
      res.json({ type, id });
    });
  },
};

# Check migration status
baasix migrate status --url http://localhost:8056

# Run pending migrations
baasix migrate run --url http://localhost:8056

baasix migrate create --name add-products-table

// migrations/20240115120000_add-products-table.js
export async function up(baasix) {
  // Create a collection
  await baasix.schema.create("products", {
    name: "Products",
    timestamps: true,
    fields: {
      id: { type: "UUID", primaryKey: true, defaultValue: { type: "UUIDV4" } },
      name: { type: "String", allowNull: false, values: { length: 255 } },
      price: { type: "Decimal", values: { precision: 10, scale: 2 } },
      status: { 
        type: "Enum", 
        values: ["published", "draft", "archived"], 
        defaultValue: "draft" 
      },
      description: { type: "Text" },
    },
  });

  // Add a relationship
  await baasix.schema.createRelationship("products", {
    name: "category",
    type: "M2O",
    target: "categories",
  });
}

export async function down(baasix) {
  await baasix.schema.delete("products");
}

# 1. Create a migration
baasix migrate create --name add-products-table

# 2. Edit the migration file in migrations/

# 3. Check what will run
baasix migrate status --url http://localhost:8056

# 4. Run migrations
baasix migrate run --url http://localhost:8056

# 5. If something goes wrong, rollback
baasix migrate rollback --url http://localhost:8056 --steps 1

BAASIX_URL=http://localhost:8056
BAASIX_EMAIL=admin@baasix.com
BAASIX_PASSWORD=admin@123

extensions/
├── baasix-hook-auth/              # Authentication hooks
├── baasix-hook-notifications/     # Notification triggers
├── baasix-endpoint-reports/       # Custom report endpoints
└── baasix-endpoint-webhooks/      # Webhook handlers

# .github/workflows/deploy.yml
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '20'
          
      - name: Install dependencies
        run: npm ci
        
      - name: Generate Types
        run: npx baasix generate --url ${{ secrets.BAASIX_URL }} -o ./src/types/baasix.d.ts -y
        
      - name: Run Migrations
        run: npx baasix migrate run --url ${{ secrets.BAASIX_URL }} -y
        
      - name: Build
        run: npm run build

Error: connect ECONNREFUSED 127.0.0.1:8056

Error: Authentication failed

Error: No schemas found