entities

// Get all records the current user has permissions to view
const myRecords = await base44.entities.MyEntity.list();

const allUsers = await base44.asServiceRole.entities.User.list();

const record = await base44.entities.MyEntity.get('entity-123');
console.log(record.name);

const page = await base44.entities.MyEntity.list({ limit: 10 });
console.log(page.items);

const page = await base44.entities.MyEntity.list({ sort: '-priority', limit: 10 });

const page = await base44.entities.MyEntity.list({ fields: ['name', 'status'], limit: 10 });

const allItems = [];
let page = await base44.entities.MyEntity.list({ sort: '-created_date', limit: 1000 });
allItems.push(...page.items);
while (page.has_more) {
  page = await base44.entities.MyEntity.list({ cursor: page.next_cursor, limit: 1000 });
  allItems.push(...page.items);
}

const { items: categories } = await base44.entities.Product.list({ distinct: 'category' });
// categories: ['books', 'electronics', 'toys']

// Each tag counts once, not each array
const { items: tags } = await base44.entities.Product.list({ distinct: 'tags' });
// tags: ['bestseller', 'clearance', 'new']

const records = await base44.entities.MyEntity.list();

const recentRecords = await base44.entities.MyEntity.list('-created_date', 10);

// Skip first 20, get next 10
const page3 = await base44.entities.MyEntity.list('-created_date', 10, 20);

const fields = await base44.entities.MyEntity.list('-created_date', 10, 0, ['name', 'status']);

const page = await base44.entities.Order.filter({ status: 'open' }, { limit: 10 });
console.log(page.items);

const page = await base44.entities.Order.filter({ status: 'open' }, { sort: '-priority', limit: 10 });

const page = await base44.entities.Order.filter({ status: 'open' }, { fields: ['status', 'region'], limit: 10 });

const allOrders = [];
let page = await base44.entities.Order.filter(
  { status: 'open' },
  { sort: '-created_date', limit: 1000 }
);
allOrders.push(...page.items);
while (page.has_more) {
  page = await base44.entities.Order.filter({ status: 'open' }, { cursor: page.next_cursor, limit: 1000 });
  allOrders.push(...page.items);
}

const { items: regions } = await base44.entities.Order.filter(
  { status: 'open' },
  { distinct: 'region' }
);
// regions: ['east', 'north', 'west']

// Each tag counts once, not each array
const { items: tags } = await base44.entities.Order.filter(
  { status: 'open' },
  { distinct: 'tags' }
);
// tags: ['gift', 'international', 'rush']

const activeRecords = await base44.entities.MyEntity.filter({
  status: 'active'
});

const filteredRecords = await base44.entities.MyEntity.filter({
  priority: 'high',
  status: 'active'
});

const records = await base44.entities.MyEntity.filter({
  external_id: ['item-1', 'item-2']
});

const popularRecords = await base44.entities.MyEntity.filter({
  count: { $gte: 100 },
  external_id: { $in: ['item-1', 'item-2'] }
});

const records = await base44.entities.MyEntity.filter({
  $or: [
    { name: 'Example item' },
    { slug: 'example-item' }
  ]
});

const recordsWithoutDescription = await base44.entities.MyEntity.filter({
  description: null
});

const results = await base44.entities.MyEntity.filter(
  { status: 'active' },
  '-created_date',
  20,
  0
);

const fields = await base44.entities.MyEntity.filter(
  { priority: 'high' },
  '-created_date',
  10,
  0,
  ['name', 'priority']
);

const open = await base44.entities.Task.count({ status: 'open' });

const total = await base44.entities.Task.count();

const pageSize = 20;
const total = await base44.entities.Task.count({ status: 'open' });
const totalPages = Math.ceil(total / pageSize);

const { rows } = await base44.entities.Sale.aggregate({
  query: { sale_date: { $gte: '2026-09-01' } },
  groupBy: 'agent_id',
  sum: 'amount',
  sort: '-sum_amount'
});
// rows: [
//   { agent_id: 'a1', count: 42, sum_amount: 18250 },
//   { agent_id: 'a2', count: 37, sum_amount: 15400 },
//   ...
// ]

const { rows } = await base44.entities.Task.aggregate({
  dateBucket: { field: 'created_date', unit: 'day' }
});
// rows: [
//   { created_date: '2026-09-01', count: 8 },
//   { created_date: '2026-09-02', count: 11 },
//   ...
// ]

const { rows } = await base44.entities.Order.aggregate({
  groupBy: 'external_id',
  having: { count: { $gt: 1 } }
});
// rows: [
//   { external_id: 'ext-42', count: 3 },
//   { external_id: 'ext-77', count: 2 }
// ]

const { rows } = await base44.entities.Order.aggregate({
  groupBy: 'product_id',
  countDistinct: 'customer_id'
});
// rows: [
//   { product_id: 'p1', count_distinct_customer_id: 86 },
//   { product_id: 'p2', count_distinct_customer_id: 34 }
// ]

const newRecord = await base44.entities.MyEntity.create({
  name: 'My Item',
  status: 'active',
  priority: 'high'
});
console.log('Created record with ID:', newRecord.id);

const result = await base44.entities.MyEntity.bulkCreate([
  { name: 'Item 1', status: 'active' },
  { name: 'Item 2', status: 'active' },
  { name: 'Item 3', status: 'completed' }
]);

const handleFileImport = async (event: React.ChangeEvent<HTMLInputElement>) => {
  const file = event.target.files?.[0];
  if (file) {
    const result = await base44.entities.MyEntity.importEntities(file);
    if (result.status === 'success' && result.output) {
      console.log(`Imported ${result.output.length} records`);
    }
  }
};

const result = await base44.entities.Product.upsert(
  supplierCatalog.map(p => ({ sku: p.sku, name: p.name, price: p.price })),
  { key: 'sku' }
);
console.log(`${result.created} new, ${result.updated} updated`);

const result = await base44.entities.Inventory.upsert(
  warehouseFeed.map(row => ({ sku: row.sku, warehouse: row.warehouseCode, quantity: row.qty })),
  { key: ['sku', 'warehouse'] }
);
console.log(`${result.created} new, ${result.updated} updated`);

const updated = await base44.entities.MyEntity.update('entity-123', {
  status: 'completed'
});

const updated = await base44.entities.MyEntity.update('entity-123', {
  name: 'Updated name',
  priority: 'low',
  status: 'active'
});

// Archive all completed orders
const result = await base44.entities.Order.updateMany(
  { status: 'completed' },
  { $set: { status: 'archived' } }
);
console.log(`Updated ${result.updated} records`);

// Flag urgent items that haven't been handled yet
const result = await base44.entities.Task.updateMany(
  { priority: { $in: ['high', 'critical'] }, status: { $ne: 'done' } },
  { $set: { flagged: true } }
);

// Close out sales records and bump the view count
const result = await base44.entities.Deal.updateMany(
  { category: 'sales' },
  { $set: { status: 'done' }, $inc: { view_count: 1 } }
);

// Process all pending items in batches of 500.
// The query filters by 'pending', so updated records (now 'processed')
// are automatically excluded from the next batch.
let hasMore = true;
let totalUpdated = 0;
while (hasMore) {
  const result = await base44.entities.Job.updateMany(
    { status: 'pending' },
    { $set: { status: 'processed' } }
  );
  totalUpdated += result.updated;
  hasMore = result.has_more;
}

// Update three invoices with different statuses and amounts
const updated = await base44.entities.Invoice.bulkUpdate([
  { id: 'inv-1', status: 'paid', amount: 999 },
  { id: 'inv-2', status: 'cancelled' },
  { id: 'inv-3', amount: 450 }
]);

// Reassign each task to a different owner in batches
const allUpdates = reassignments.map(r => ({ id: r.taskId, owner: r.newOwner }));
for (let i = 0; i < allUpdates.length; i += 500) {
  const batch = allUpdates.slice(i, i + 500);
  await base44.entities.Task.bulkUpdate(batch);
}

const result = await base44.entities.MyEntity.delete('entity-123');
console.log('Deleted:', result.success);

const result = await base44.entities.MyEntity.deleteMany({
  status: 'completed',
  priority: 'low'
});
console.log('Deleted:', result.deleted);

const unsubscribe = base44.entities.Task.subscribe((event) => {
  console.log(`Task ${event.id} was ${event.type}d:`, event.data);
});

// Later, clean up the subscription
unsubscribe();

// Combine your schema with server fields (id, created_date, etc.)
type TaskRecord = EntityRecord['Task'];

const task: TaskRecord = await base44.entities.Task.create({
  title: 'My task',
  status: 'pending'
});

// Task now includes both your fields and server fields:
console.log(task.id);           // Server field
console.log(task.created_date); // Server field
console.log(task.title);        // Your field

// Ascending sort
'created_date'
'+created_date'

// Descending sort
'-created_date'

const query: EntityFilterQuery<Task> = {
  status: 'open',
  priority: { $gte: 3 },
  $or: [{ assignee: 'me' }, { team: 'core' }]
};