create-protobase 0.23.13 → 0.24.0

package/dist/templates/real-estate/config/pages.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+import { checkPages } from '@protobase/layout'
+import { configExports } from '@protobase/server'
+import * as config from './index'
+
+describe('real estate pages', () => {
+  it('name only resources, fields, filters and actions the example has', () => {
+    const { resources, views, pages } = configExports(config)
+    const models = Object.fromEntries(resources.map((source) => [source.toModel().name, source.toModel()]))
+    const actions = (resource: string) => new Set(views.map((view) => view.toModel()).filter((view) => view.resource === resource).flatMap((view) => view.actions.map((action) => action.name)))
+    expect(pages.map((entry) => entry.name)).toEqual(['accounts', 'overview'])
+    expect(() => checkPages(pages.map((entry) => entry.toModel()), { models, actions })).not.toThrow()
+  })
+
+  it('has a list and record view for every table', () => {
+    const { resources, views } = configExports(config)
+    const viewed = new Set(views.map((view) => view.toModel().resource))
+    expect(resources.map((source) => source.toModel().name).filter((name) => !viewed.has(name))).toEqual([])
+    expect(resources).toHaveLength(19)
+  })
+
+  it('lists a lease\'s rent charges on its page, newest period first, a year of them', () => {
+    const { resources, views } = configExports(config)
+    const charges = resources.map((source) => source.toModel()).find((model) => model.name === 'rent_charges')!
+    const lease = views.map((view) => view.toModel()).find((view) => view.resource === 'leases')!
+    const section = lease.layout.find((item) => item.kind === 'related' && item.title === 'Rent charges')
+    expect(section).toMatchObject({ resource: 'rent_charges', field: 'lease_id', sort: 'period desc', limit: 12 })
+    expect(section?.kind === 'related' && section.columns?.filter((column) => !Object.hasOwn(charges.fields, column))).toEqual([])
+    expect(section?.kind === 'related' && section.columns?.slice(-2)).toEqual(['paid_amount', 'outstanding'])
+  })
+
+  it('shows what is still owed on a rent charge: a read-only, filterable column formatted like the amount', () => {
+    const { resources, views } = configExports(config)
+    const charges = resources.map((source) => source.toModel()).find((model) => model.name === 'rent_charges')!
+    const view = views.map((entry) => entry.toModel()).find((entry) => entry.resource === 'rent_charges')!
+    expect(charges.fields.outstanding).toMatchObject({ type: 'decimal', readOnly: true, filterable: true, sortable: true })
+    expect(view.fields.outstanding).toMatchObject({ prefix: '€', decimals: 2 })
+    expect(view.list?.columns.slice(-2)).toEqual(['paid_amount', 'outstanding'])
+  })
+
+  it('lists a rent charge\'s payments on its page, newest first', () => {
+    const { resources, views } = configExports(config)
+    const payments = resources.map((source) => source.toModel()).find((model) => model.name === 'payments')!
+    const charge = views.map((view) => view.toModel()).find((view) => view.resource === 'rent_charges')!
+    const section = charge.layout.find((item) => item.kind === 'related' && item.title === 'Payments')
+    expect(section).toMatchObject({ resource: 'payments', field: 'charge_id', sort: 'paid_on desc', columns: ['paid_on', 'amount', 'method', 'reference'] })
+    expect(section?.kind === 'related' && section.columns?.filter((column) => !Object.hasOwn(payments.fields, column))).toEqual([])
+  })
+})

package/dist/templates/real-estate/config/payments/data.ts

@@ -0,0 +1,20 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** billing.payments. Postgres refuses payments that add up to more than their charge. */
+export const payments = resource('payments')
+  .table('billing.payments')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    charge_id: f.relation('rent_charges').filterable().sortable(),
+    paid_on: f.date().filterable().sortable(),
+    amount: f.decimal({ precision: 10, scale: 2 }),
+    method: f.enum(['direct_debit', 'bank_transfer', 'ideal']).filterable().sortable(),
+    reference: f.text().optional(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(access('payments'))

package/dist/templates/real-estate/config/payments/ui.ts

@@ -0,0 +1,14 @@
+import { view } from '@protobase/schema'
+import type { payments } from './data'
+
+export const paymentsView = view<typeof payments>('payments')
+  .names({ singular: 'Payment', plural: 'Payments' })
+  .fields((r) => ({
+    charge_id: r.charge_id.label('Charge'),
+    paid_on: r.paid_on.label('Paid on'),
+    amount: r.amount.prefix('€').decimals(2),
+    method: r.method.help('Direct debit is collected on the first; transfers and iDEAL come in when the tenant pays.').format('badge').valueLabels({ direct_debit: 'Direct debit', bank_transfer: 'Bank transfer', ideal: 'iDEAL' }),
+  }))
+  .list((r) => ({ columns: [r.charge_id, r.paid_on, r.amount, r.method, r.reference], sort: [[r.paid_on, 'desc']] }))
+  .filters((r, w) => [w.facets(r.method), w.dateRange(r.paid_on, { presets: ['7d', '30d', '90d', 'year'] })])
+  .chart((r) => ({ field: r.paid_on, range: '90d', granularity: 'week' }))

package/dist/templates/real-estate/config/properties/data.ts

@@ -0,0 +1,26 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.properties: a building or a house, with its location as latitude and longitude. */
+export const properties = resource('properties')
+  .table('portfolio.properties')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    owner_id: f.relation('owners').filterable().sortable(),
+    name: f.text(),
+    kind: f.enum(['apartment_building', 'single_family', 'mixed_use']).filterable().sortable(),
+    street: f.text(),
+    house_number: f.text(),
+    postal_code: f.text().regex(/^[1-9]\d{3} [A-Z]{2}$/, 'A Dutch postal code, such as 1017 CT'),
+    city: f.text().filterable().sortable(),
+    latitude: f.decimal({ precision: 8, scale: 6 }).filterable().sortable(),
+    longitude: f.decimal({ precision: 9, scale: 6 }),
+    built_year: f.integer().min(1500).max(2100),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .search((r) => [r.name])
+  .access(access('properties'))

package/dist/templates/real-estate/config/properties/ui.ts

@@ -0,0 +1,21 @@
+import { l, view } from '@protobase/schema'
+import type { properties } from './data'
+
+export const propertiesView = view<typeof properties>('properties')
+  .title((r) => r.name)
+  .names({ singular: 'Property', plural: 'Properties' })
+  .fields((r) => ({
+    kind: r.kind.format('badge').valueLabels({ apartment_building: 'Apartment building', single_family: 'Single-family', mixed_use: 'Mixed-use' }),
+    owner_id: r.owner_id.label('Owner'),
+    latitude: r.latitude.help('Decimal degrees, WGS84.').decimals(6),
+    longitude: r.longitude.help('Decimal degrees, WGS84.').decimals(6),
+    built_year: r.built_year.label('Built'),
+  }))
+  .list((r) => ({ columns: [r.name, r.kind, r.city, r.postal_code, r.owner_id, r.built_year], search: [r.name] }))
+  .filters((r, w) => [w.facets(r.kind), w.facets(r.city), w.facets(r.owner_id, { search: true })])
+  .layout((r) => [
+    l.section('Property', [r.name, r.kind, r.owner_id, r.built_year]),
+    l.section('Address', [r.street, r.house_number, r.postal_code, r.city]),
+    l.section('Location', [r.latitude, r.longitude], { help: 'Where the property is on a map.' }),
+    l.sidebar([r.kind, r.city, r.owner_id]),
+  ])

package/dist/templates/real-estate/config/rent_charges/data.ts

@@ -0,0 +1,22 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** billing.rent_charges: one per lease and month. Unique: (lease_id, period). `paid_amount` follows the payments; `outstanding` is a generated column, amount minus paid. */
+export const rentCharges = resource('rent_charges')
+  .table('billing.rent_charges')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    lease_id: f.relation('leases').filterable().sortable(),
+    period: f.date().filterable().sortable(),
+    due_on: f.date().filterable().sortable(),
+    description: f.text(),
+    amount: f.decimal({ precision: 10, scale: 2 }).filterable().sortable(),
+    paid_amount: f.decimal({ precision: 10, scale: 2 }).readOnly().default('0'),
+    outstanding: f.decimal({ precision: 10, scale: 2 }).readOnly().filterable().sortable(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(access('rent_charges'))

package/dist/templates/real-estate/config/rent_charges/ui.ts

@@ -0,0 +1,27 @@
+import { l, view } from '@protobase/schema'
+import type { rentCharges } from './data'
+
+export const rentChargesView = view<typeof rentCharges>('rent_charges')
+  .title((r) => r.description)
+  .names({ singular: 'Rent charge', plural: 'Rent charges' })
+  .fields((r) => ({
+    lease_id: r.lease_id.label('Lease'),
+    period: r.period.help('The month the charge is for.'),
+    due_on: r.due_on.label('Due'),
+    amount: r.amount.help('Rent plus service costs for the month.').prefix('€').decimals(2),
+    paid_amount: r.paid_amount.label('Paid').help('The sum of the payments on this charge.').prefix('€').decimals(2),
+    outstanding: r.outstanding.help('What is still owed: the amount minus the payments.').prefix('€').decimals(2),
+  }))
+  .list((r) => ({ columns: [r.description, r.lease_id, r.due_on, r.amount, r.paid_amount, r.outstanding], sort: [[r.period, 'desc']] }))
+  .filters((r, w) => [w.dateRange(r.period, { presets: ['90d', 'quarter', 'year'] }), w.range(r.amount, { histogram: true })])
+  .layout((r) => [
+    l.section('Charge', [r.lease_id, r.period, r.due_on, r.description, r.amount]),
+    l.related('Payments', {
+      resource: 'payments',
+      field: 'charge_id',
+      sort: 'paid_on desc',
+      columns: ['paid_on', 'amount', 'method', 'reference'],
+      empty: 'No payments yet.',
+    }),
+    l.sidebar([r.amount, r.paid_amount, r.outstanding]),
+  ])

package/dist/templates/real-estate/config/roles.test.ts

@@ -0,0 +1,49 @@
+import { resolveAccess } from '@protobase/schema'
+import { describe, expect, it } from 'vitest'
+import { arrears, leases, payments, tenants, tickets } from './index'
+
+const as = (role: string) => ({ user: { id: 6, roles: [role] } })
+
+describe('real estate roles', () => {
+  // role, read, create, update, delete
+  it.each([
+    ['admin', true, true, true, true],
+    ['manager', true, true, true, false],
+    ['finance', true, false, false, false],
+    ['maintenance', false, false, false, false],
+  ] as const)('leases as %s', async (role, read, create, update, remove) => {
+    const access = await resolveAccess(leases, as(role))
+    expect(access.operations).toEqual({ list: read, read, create, update, delete: remove })
+  })
+
+  it.each([
+    ['admin', true, true, true, true],
+    ['manager', true, false, false, false],
+    ['finance', true, true, true, true],
+    ['maintenance', false, false, false, false],
+  ] as const)('payments as %s', async (role, read, create, update, remove) => {
+    const access = await resolveAccess(payments, as(role))
+    expect(access.operations).toEqual({ list: read, read, create, update, delete: remove })
+  })
+
+  it.each(['admin', 'manager', 'finance', 'maintenance'])('arrears are read-only for %s', async (role) => {
+    const access = await resolveAccess(arrears, as(role))
+    expect(access.operations).toMatchObject({ create: false, update: false, delete: false, read: role !== 'maintenance' })
+  })
+
+  it('lets maintenance change only the tickets assigned to them', async () => {
+    const access = await resolveAccess(tickets, as('maintenance'))
+    expect(access.operations).toMatchObject({ read: true, create: true, update: true, delete: false })
+    expect(access.rowFilter.read).toBeUndefined()
+    expect(access.rowFilter.update).toMatchObject({ kind: 'compare', field: { name: 'assigned_to' }, value: { value: 6 } })
+  })
+
+  it.each([
+    ['admin', true], ['manager', true], ['finance', true], ['maintenance', false],
+  ] as const)("shows a tenant's income and IBAN to %s: %s", async (role, visible) => {
+    const access = await resolveAccess(tenants, as(role))
+    expect(access.readableFields).toContain('phone')
+    expect(access.readableFields.includes('monthly_income')).toBe(visible)
+    expect(access.readableFields.includes('iban')).toBe(visible)
+  })
+})

package/dist/templates/real-estate/config/roles.ts

@@ -0,0 +1,45 @@
+import { defineRoles } from '@protobase/schema'
+
+/** Resources plus the area that gates tenants' income and bank details. */
+export type RealEstateName =
+  | 'organizations' | 'users' | 'amenities' | 'owners' | 'properties' | 'units' | 'unit_amenities' | 'valuations'
+  | 'tenants' | 'leases' | 'lease_tenants' | 'deposits' | 'rent_charges' | 'payments' | 'arrears'
+  | 'vendors' | 'tickets' | 'work_orders' | 'inspections'
+  | 'screening'
+
+/**
+ * Capabilities are `<resource|area>.<action>[.own]`. Property managers run the portfolio and the leases, finance the
+ * money, maintenance the tickets; `.own` tickets are those assigned to the user. The `screening` area gates a tenant's
+ * income and IBAN, which maintenance staff, who call tenants to plan a visit, do not see.
+ */
+export const roles = defineRoles<RealEstateName>({
+  admin: ['*'],
+  manager: [
+    'owners.read', 'owners.create', 'owners.update',
+    'properties.read', 'properties.create', 'properties.update',
+    'units.read', 'units.create', 'units.update', 'unit_amenities.*', 'amenities.read', 'valuations.read',
+    'tenants.read', 'tenants.create', 'tenants.update', 'screening.read',
+    'leases.read', 'leases.create', 'leases.update', 'lease_tenants.*', 'deposits.read',
+    'rent_charges.read', 'payments.read', 'arrears.read',
+    'tickets.read', 'tickets.create', 'tickets.update', 'work_orders.read', 'vendors.read', 'inspections.*',
+    'organizations.read', 'users.read',
+  ],
+  finance: [
+    'rent_charges.*', 'payments.*', 'arrears.read', 'deposits.*', 'valuations.*',
+    'leases.read', 'lease_tenants.read', 'tenants.read', 'screening.read',
+    'units.read', 'properties.read', 'owners.read', 'work_orders.read', 'vendors.read',
+    'organizations.read', 'users.read',
+  ],
+  maintenance: [
+    'tickets.read', 'tickets.create', 'tickets.update.own', 'work_orders.*', 'inspections.*', 'vendors.*',
+    'properties.read', 'units.read', 'amenities.read', 'unit_amenities.read', 'tenants.read', 'users.read',
+  ],
+})
+
+/** The standard rule set for a resource: every operation needs the matching capability. */
+export const access = (name: RealEstateName) => ({
+  read: roles.can(`${name}.read`),
+  create: roles.can(`${name}.create`),
+  update: roles.can(`${name}.update`),
+  delete: roles.can(`${name}.delete`),
+})

package/dist/templates/real-estate/config/shell.test.ts

@@ -0,0 +1,18 @@
+import { createAdmin, configExports } from '@protobase/server'
+import { describe, expect, it } from 'vitest'
+import * as config from './index'
+
+describe('real estate sidebar and user menu', () => {
+  const { resources, views, pages, userMenu } = configExports(config)
+
+  it('has recent groups that fit their resources', () => {
+    const grouped = views.map((view) => view.toModel()).filter((view) => view.nav?.recent)
+    expect(grouped.map((view) => view.resource).sort()).toEqual(['tickets', 'units'])
+    // createAdmin refuses a group or a user menu entry that does not fit, before any request.
+    expect(() => createAdmin({ resources, views, pages, userMenu, db: {} as never, authenticate: () => { throw new Error('No requests in this test') } })).not.toThrow()
+  })
+
+  it('moves the account pages into the user menu', () => {
+    expect(userMenu?.toUserMenuModel().items.map((item) => (item.kind === 'resource' ? item.resource : item.kind === 'page' ? item.page : item.label))).toEqual(['organizations', 'accounts', 'Documentation', 'Support'])
+  })
+})

package/dist/templates/real-estate/config/tenants/data.ts

@@ -0,0 +1,23 @@
+import { f, resource } from '@protobase/schema'
+import { access, roles } from '../roles'
+
+/** leasing.tenants. Income and IBAN are screening data: only roles holding `screening.read` see them, and the IBAN only when revealed. */
+export const tenants = resource('tenants')
+  .table('leasing.tenants')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    first_name: f.text(),
+    last_name: f.text().filterable().sortable(),
+    email: f.text(),
+    phone: f.text().optional(),
+    date_of_birth: f.date(),
+    iban: f.text().sensitive().access({ read: roles.can('screening.read') }),
+    monthly_income: f.decimal({ precision: 10, scale: 2 }).access({ read: roles.can('screening.read') }),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .search((r) => [r.first_name, r.last_name, r.email, r.phone.digitsEnd()])
+  .access(access('tenants'))

package/dist/templates/real-estate/config/tenants/ui.ts

@@ -0,0 +1,27 @@
+import { l, view } from '@protobase/schema'
+import type { tenants } from './data'
+
+export const tenantsView = view<typeof tenants>('tenants')
+  .title((r) => r.last_name)
+  .searchResult((r) => ({ title: [r.first_name, r.last_name], subtitle: r.email }))
+  .names({ singular: 'Tenant', plural: 'Tenants' })
+  .fields((r) => ({
+    iban: r.iban.label('IBAN').format('code'),
+    monthly_income: r.monthly_income.help('Gross income per month, checked when the lease was signed.').prefix('€').decimals(2),
+  }))
+  .list((r) => ({ columns: [r.last_name, r.first_name, r.email, r.phone, r.created_at], sort: [[r.created_at, 'desc']], search: [r.last_name, r.email] }))
+  .filters((r, w) => [w.dateRange(r.created_at, { presets: ['30d', '90d', 'year'] })])
+  .layout((r) => [
+    l.section('Tenant', [r.first_name, r.last_name, r.date_of_birth, r.email, r.phone]),
+    l.section('Screening', [r.monthly_income, r.iban], { help: 'Seen by property managers and finance only. Showing the IBAN is logged.' }),
+    l.related('Homes', {
+      resource: 'leases',
+      field: 'id',
+      through: { resource: 'lease_tenants', field: 'tenant_id', key: 'lease_id' },
+      // Running indefinite leases have no end date, which sorts first
+      sort: 'end_date desc, start_date desc',
+      columns: ['number', 'unit_id.property_id', 'unit_id', 'start_date', 'end_date', 'monthly_rent'],
+      help: 'The properties and units this tenant rents or rented, current leases first.',
+      empty: 'This tenant has not signed a lease.',
+    }),
+  ])

package/dist/templates/real-estate/config/tickets/data.ts

@@ -0,0 +1,33 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/**
+ * maintenance.tickets. Unique: (organization_id, number). The status only moves forward (reported, scheduled, then done
+ * or cancelled); Postgres refuses any other step and stamps `closed_at`. Maintenance staff change the tickets assigned
+ * to them (`.own`).
+ */
+export const tickets = resource('tickets')
+  .table('maintenance.tickets')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    number: f.text().filterable().sortable(),
+    property_id: f.relation('properties').filterable().sortable(),
+    unit_id: f.relation('units').optional().filterable().sortable(),
+    reported_by: f.relation('tenants').optional().filterable().sortable(),
+    assigned_to: f.relation('users').optional().filterable().sortable(),
+    category: f.enum(['heating', 'plumbing', 'electrical', 'leak', 'mould', 'locks', 'appliances', 'windows_doors', 'garden', 'pests']).filterable().sortable(),
+    priority: f.enum(['low', 'normal', 'high', 'urgent']).default('normal').filterable().sortable(),
+    status: f.enum(['reported', 'scheduled', 'done', 'cancelled']).default('reported').filterable().sortable(),
+    title: f.text(),
+    description: f.text().optional(),
+    reported_at: f.timestamp().filterable().sortable().dbDefault(),
+    closed_at: f.timestamp().readOnly().optional(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .owner((r) => r.assigned_to)
+  .search((r) => [r.number, r.title])
+  .access(access('tickets'))

package/dist/templates/real-estate/config/tickets/ui.ts

@@ -0,0 +1,58 @@
+import { l, view } from '@protobase/schema'
+import type { tickets } from './data'
+
+export const ticketsView = view<typeof tickets>('tickets')
+  .title((r) => r.number)
+  .names({ singular: 'Ticket', plural: 'Tickets' })
+  .nav({
+    recent: {
+      status: 'priority',
+      tones: { urgent: 'danger', high: 'warning', normal: 'info' },
+      pulse: ['urgent'],
+      filter: 'status = "reported" OR status = "scheduled"',
+      orderBy: 'reported_at desc',
+    },
+  })
+  .fields((r) => ({
+    number: r.number.format('code'),
+    category: r.category.valueLabels({
+      heating: 'Heating',
+      plumbing: 'Plumbing',
+      electrical: 'Electrical',
+      leak: 'Leak',
+      mould: 'Mould',
+      locks: 'Locks',
+      appliances: 'Appliances',
+      windows_doors: 'Windows & doors',
+      garden: 'Garden',
+      pests: 'Pests',
+    }),
+    property_id: r.property_id.label('Property'),
+    unit_id: r.unit_id.label('Unit').help('Empty when the whole building is affected.'),
+    reported_by: r.reported_by.label('Reported by'),
+    assigned_to: r.assigned_to.label('Assigned to').help('The maintenance coordinator who plans the work.'),
+    priority: r.priority.format('badge').valueLabels({ low: 'Low', normal: 'Normal', high: 'High', urgent: 'Urgent' }),
+    status: r.status.help('Reported, then scheduled once a vendor visit is planned, then done or cancelled.').format('badge').valueLabels({ reported: 'Reported', scheduled: 'Scheduled', done: 'Done', cancelled: 'Cancelled' }),
+    reported_at: r.reported_at.label('Reported'),
+    closed_at: r.closed_at.label('Closed'),
+  }))
+  .list((r) => ({ columns: [r.number, r.title, r.property_id, r.category, r.priority, r.status, r.reported_at], sort: [[r.reported_at, 'desc']], search: [r.number, r.title] }))
+  .filters((r, w) => [
+    w.facets(r.status),
+    w.facets(r.priority),
+    w.facets(r.category),
+    w.facets(r.assigned_to),
+    w.dateRange(r.reported_at, { presets: ['7d', '30d', '90d', 'year'] }),
+  ])
+  .chart((r) => ({ field: r.reported_at, range: '90d', granularity: 'week' }))
+  .layout((r) => [
+    l.section('Problem', [r.title, r.description, r.category, r.priority]),
+    l.section('Where', [r.property_id, r.unit_id, r.reported_by]),
+    l.section('Handling', [r.status, r.assigned_to, r.reported_at, r.closed_at]),
+    l.sidebar([r.status, r.priority, r.assigned_to]),
+  ])
+  .actions((a) => [
+    a.update('schedule', { label: 'Mark scheduled', icon: 'calendar', set: { status: 'scheduled' } }),
+    a.update('complete', { label: 'Mark done', icon: 'check', set: { status: 'done' }, confirm: 'Close this ticket as done?' }),
+    a.update('cancel', { label: 'Cancel', icon: 'x', set: { status: 'cancelled' }, confirm: 'Cancel this ticket?' }),
+  ])

package/dist/templates/real-estate/config/unit_amenities/data.ts

@@ -0,0 +1,15 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.unit_amenities, the join between units and amenities. */
+export const unitAmenities = resource('unit_amenities')
+  .table('portfolio.unit_amenities')
+  .fields({
+    unit_id: f.relation('units').filterable().sortable(),
+    amenity_code: f.relation('amenities').filterable().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    added_at: f.timestamp().dbDefault(),
+  })
+  .primaryKey((r) => [r.unit_id, r.amenity_code])
+  .tenant((r) => r.organization_id)
+  .access(access('unit_amenities'))

package/dist/templates/real-estate/config/unit_amenities/ui.ts

@@ -0,0 +1,8 @@
+import { view } from '@protobase/schema'
+import type { unitAmenities } from './data'
+
+export const unitAmenitiesView = view<typeof unitAmenities>('unit_amenities')
+  .nav({ hidden: true })
+  .names({ singular: 'Unit amenity', plural: 'Unit amenities' })
+  .fields((r) => ({ amenity_code: r.amenity_code.label('Amenity') }))
+  .list((r) => ({ columns: [r.unit_id, r.amenity_code, r.added_at] }))

package/dist/templates/real-estate/config/units/data.ts

@@ -0,0 +1,24 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.units: a home that is let on its own. Unique: (property_id, label) */
+export const units = resource('units')
+  .table('portfolio.units')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    property_id: f.relation('properties').filterable().sortable(),
+    label: f.text(),
+    floor: f.integer().default(0),
+    bedrooms: f.integer().min(0),
+    area_m2: f.integer().min(1).column('area_m2'),
+    energy_label: f.enum(['A++++', 'A+++', 'A++', 'A+', 'A', 'B', 'C', 'D', 'E', 'F', 'G']).filterable().sortable(),
+    base_rent: f.decimal({ precision: 10, scale: 2 }).filterable().sortable(),
+    status: f.enum(['let', 'vacant', 'renovation']).default('vacant').filterable().sortable(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .search((r) => [r.label])
+  .access(access('units'))

package/dist/templates/real-estate/config/units/ui.ts

@@ -0,0 +1,41 @@
+import { l, view } from '@protobase/schema'
+import type { units } from './data'
+
+/** A lease that covers today; `end_date` is its last day. */
+const running = 'start_date <= now() AND (isNull(end_date) OR end_date >= now())'
+
+export const unitsView = view<typeof units>('units')
+  .title((r) => r.label)
+  .names({ singular: 'Unit', plural: 'Units' })
+  .nav({ recent: { status: 'status', tones: { vacant: 'warning', renovation: 'info' }, filter: 'status != "let"' } })
+  .fields((r) => ({
+    property_id: r.property_id.label('Property'),
+    area_m2: r.area_m2.label('Area').help('Living area in m².').suffix(' m²'),
+    energy_label: r.energy_label.format('badge'),
+    base_rent: r.base_rent.label('Market rent').help('What a new lease would ask today, per month.').prefix('€').decimals(2),
+    status: r.status.help('Let while a lease runs; vacant or under renovation between leases.').format('badge').valueLabels({ let: 'Let', vacant: 'Vacant', renovation: 'Renovation' }),
+  }))
+  .list((r) => ({ columns: [r.label, r.property_id, r.status, r.bedrooms, r.area_m2, r.energy_label, r.base_rent], search: [r.label] }))
+  .filters((r, w) => [w.facets(r.status), w.facets(r.energy_label), w.range(r.base_rent, { histogram: true })])
+  .layout((r) => [
+    l.section('Unit', [r.property_id, r.label, r.floor, r.bedrooms, r.area_m2, r.energy_label]),
+    l.section('Letting', [r.status, r.base_rent]),
+    l.related('Let to', {
+      resource: 'lease_tenants',
+      field: 'lease_id',
+      through: { resource: 'leases', field: 'unit_id', filter: running },
+      // `primary` sorts after `co_signer`, so the primary tenant comes first
+      sort: 'role desc',
+      columns: ['tenant_id', 'role', 'tenant_id.email', 'tenant_id.phone'],
+      help: 'The primary tenant and co-signers of the running lease.',
+      empty: 'Vacant: no lease runs today.',
+    }),
+    l.related('Running lease', {
+      resource: 'leases',
+      field: 'unit_id',
+      filter: running,
+      columns: ['number', 'term', 'start_date', 'end_date', 'monthly_rent', 'service_costs'],
+      empty: 'Vacant: no lease runs today.',
+    }),
+    l.sidebar([r.status, r.base_rent]),
+  ])

package/dist/templates/real-estate/config/user-menu.ts

@@ -0,0 +1,9 @@
+import { userMenu } from '@protobase/schema'
+
+/** Account pages under the signed-in user instead of in the sidebar, then help. */
+export const accountMenu = userMenu((m) => [
+  m.resource('organizations', { label: 'Organization', icon: 'building' }),
+  m.page('accounts', { label: 'Users', icon: 'users' }),
+  m.link('Documentation', 'https://docs.protobase.net', { icon: 'book-open' }),
+  m.link('Support', 'mailto:support@example.com', { icon: 'life-buoy' }),
+])

package/dist/templates/real-estate/config/users/data.ts

@@ -0,0 +1,19 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** core.users. Unique: (organization_id, email) */
+export const users = resource('users')
+  .table('core.users')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    email: f.text().filterable().sortable(),
+    name: f.text(),
+    role: f.enum(['admin', 'manager', 'finance', 'maintenance']).optional().filterable().sortable(),
+    active: f.boolean().default(true),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(access('users'))

package/dist/templates/real-estate/config/users/ui.ts

@@ -0,0 +1,11 @@
+import { view } from '@protobase/schema'
+import type { users } from './data'
+
+export const usersView = view<typeof users>('users')
+  .title((r) => r.name)
+  .names({ singular: 'User', plural: 'Users' })
+  // Reached from the records that name a user; the profile menu's Users is the accounts page.
+  .nav({ hidden: true })
+  .fields((r) => ({ role: r.role.format('badge').valueLabels({ admin: 'Admin', manager: 'Manager', finance: 'Finance', maintenance: 'Maintenance' }) }))
+  .list((r) => ({ columns: [r.name, r.email, r.role, r.active] }))
+  .filters((r, w) => [w.facets(r.role)])

package/dist/templates/real-estate/config/valuations/data.ts

@@ -0,0 +1,19 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.valuations: a property's value over time. Unique: (property_id, source, valued_on) */
+export const valuations = resource('valuations')
+  .table('portfolio.valuations')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    property_id: f.relation('properties').filterable().sortable(),
+    valued_on: f.date().filterable().sortable(),
+    value: f.decimal({ precision: 14, scale: 2 }),
+    source: f.enum(['woz', 'appraisal']).filterable().sortable(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(access('valuations'))

package/dist/templates/real-estate/config/valuations/ui.ts

@@ -0,0 +1,13 @@
+import { view } from '@protobase/schema'
+import type { valuations } from './data'
+
+export const valuationsView = view<typeof valuations>('valuations')
+  .names({ singular: 'Valuation', plural: 'Valuations' })
+  .fields((r) => ({
+    property_id: r.property_id.label('Property'),
+    valued_on: r.valued_on.label('Valuation date'),
+    value: r.value.prefix('€').decimals(0),
+    source: r.source.help('WOZ is the municipal value set every year; an appraisal is a valuer\'s report.').format('badge').valueLabels({ woz: 'WOZ', appraisal: 'Appraisal' }),
+  }))
+  .list((r) => ({ columns: [r.property_id, r.valued_on, r.source, r.value], sort: [[r.valued_on, 'desc']] }))
+  .filters((r, w) => [w.facets(r.source), w.dateRange(r.valued_on, { presets: ['year'] })])