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