create-protobase 0.23.13 → 0.24.0

package/dist/templates/erp/seed/steps/warehouses.ts

@@ -0,0 +1,42 @@
+import type { Db } from '../../db/connection'
+import { DAY, windowStart } from '../calendar'
+import { copyRows } from '../copy'
+import { aislesPerZone, binsPerAisle, zones } from '../data/layout'
+import { iso, row } from '../format'
+import type { World } from '../world'
+
+const createdAt = iso(windowStart - 4 * 365 * DAY)
+const label = (prefix: string, number: number) => `${prefix}_${String(number).padStart(2, '0')}`
+
+function* warehouseRows(world: World) {
+  for (const org of world.orgs) {
+    for (const warehouse of org.warehouses) yield row(warehouse.id, org.id, warehouse.code, warehouse.name, warehouse.city, warehouse.country, createdAt, createdAt)
+  }
+}
+
+// Depth-first, matching the offsets in data/layout.ts.
+function* locationRows(world: World) {
+  for (const org of world.orgs) {
+    for (const warehouse of org.warehouses) {
+      const root = warehouse.code.toLowerCase().replace('-', '_')
+      let id = warehouse.firstLocationId
+      const location = (path: string, name: string) => row(id++, org.id, warehouse.id, path, name, createdAt, createdAt)
+      for (let zone = 0; zone < zones; zone++) {
+        const zoneLabel = `zone_${String.fromCharCode(97 + zone)}`
+        yield location(`${root}.${zoneLabel}`, `Zone ${String.fromCharCode(65 + zone)}`)
+        for (let aisle = 1; aisle <= aislesPerZone; aisle++) {
+          const aisleLabel = label('aisle', aisle)
+          yield location(`${root}.${zoneLabel}.${aisleLabel}`, `Zone ${String.fromCharCode(65 + zone)} / Aisle ${aisle}`)
+          for (let bin = 1; bin <= binsPerAisle; bin++) {
+            yield location(`${root}.${zoneLabel}.${aisleLabel}.bin_${bin}`, `Zone ${String.fromCharCode(65 + zone)} / Aisle ${aisle} / Bin ${bin}`)
+          }
+        }
+      }
+    }
+  }
+}
+
+export const seedWarehouses = async (sql: Db, world: World) => {
+  await copyRows(sql, 'inventory.warehouses (id, organization_id, code, name, city, country_code, created_at, updated_at)', warehouseRows(world))
+  await copyRows(sql, 'inventory.locations (id, organization_id, warehouse_id, path, name, created_at, updated_at)', locationRows(world))
+}

package/dist/templates/erp/seed/world.ts

@@ -0,0 +1,86 @@
+import { categories } from './builders/categories'
+import { timestamps } from './calendar'
+import { locationsPerWarehouse } from './data/layout'
+import { orgSpecs, tagNames } from './data/reference'
+import { rngAt, weighted } from './rng'
+import { scales, type ScaleName } from './scales'
+
+export const employeesPerOrg = 40
+
+// Splits a scale total over the organizations by share; the last one takes the remainder.
+const splitTotal = (total: number) => {
+  const parts: number[] = []
+  for (const [index, spec] of orgSpecs.entries()) {
+    parts.push(index === orgSpecs.length - 1 ? total - parts.reduce((sum, part) => sum + part, 0) : Math.round(total * spec.share))
+  }
+  return parts
+}
+
+// Every table's ids are allocated here, so builders can compute foreign keys without lookups.
+export const buildWorld = (name: ScaleName) => {
+  const scale = scales[name]
+  const companies = splitTotal(scale.companies)
+  const orders = splitTotal(scale.orders)
+  const moves = splitTotal(scale.moves)
+  const next = { user: 1, company: 1, person: 1, tag: 1, category: 1, product: 1, order: 0, warehouse: 1, location: 1, move: 1, employee: 1 }
+
+  const orgs = orgSpecs.map((spec, index) => {
+    const companyCount = companies[index]!
+    const personStarts = new Uint32Array(companyCount + 1)
+    for (let ordinal = 0; ordinal < companyCount; ordinal++) {
+      personStarts[ordinal + 1] = personStarts[ordinal]! + weighted(rngAt(spec.seed + 3, ordinal), [[1, 30], [2, 40], [3, 30]] as const)
+    }
+    const users = spec.users.map(([first, initial, role], position) => ({
+      id: next.user + position,
+      name: `${first} ${initial}`,
+      email: `${first.toLowerCase()}@${spec.slug}.example`,
+      role,
+    }))
+    const warehouses = spec.warehouses.map(([code, warehouseName, city, country], position) => ({
+      id: next.warehouse + position,
+      code,
+      name: warehouseName,
+      city,
+      country,
+      firstLocationId: next.location + position * locationsPerWarehouse,
+    }))
+    const org = {
+      ...spec,
+      users,
+      salesUsers: users.filter((user) => user.role === 'sales'),
+      warehouseUsers: users.filter((user) => user.role === 'warehouse'),
+      warehouses,
+      companyCount,
+      companyFirstId: next.company,
+      personStarts,
+      personFirstId: next.person,
+      tagFirstId: next.tag,
+      categoryFirstId: next.category,
+      productCount: scale.productsPerOrg,
+      productFirstId: next.product,
+      orderCount: orders[index]!,
+      orderFirstId: next.order,
+      orderTimes: timestamps(orders[index]!, spec.seed + 5),
+      moveCount: moves[index]!,
+      moveFirstId: next.move,
+      employeeFirstId: next.employee,
+    }
+    next.user += users.length
+    next.company += companyCount
+    next.person += personStarts[companyCount]!
+    next.tag += tagNames.length
+    next.category += categories.length
+    next.product += scale.productsPerOrg
+    next.order += org.orderCount
+    next.warehouse += warehouses.length
+    next.location += warehouses.length * locationsPerWarehouse
+    next.move += org.moveCount
+    next.employee += employeesPerOrg
+    return org
+  })
+
+  return { name, orgs }
+}
+
+export type World = ReturnType<typeof buildWorld>
+export type Org = World['orgs'][number]

package/dist/templates/erp/vitest.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from 'vitest/config'
+
+// The unit tests next to the config and the seed; none of them needs a database.
+export default defineConfig({ test: { include: ['config/**/*.test.ts', 'seed/**/*.test.ts'] } })

package/dist/templates/real-estate/.env.example

@@ -0,0 +1,9 @@
+# The real estate example's own settings. The nearest .env wins, so this file, not the repository's, is the one
+# `protobase dev`, `protobase serve` and the db:* scripts read here. The Postgres container is the repository's (`bun run db:up`).
+DATABASE_URL=postgres://protobase:protobase@localhost:55432/real_estate
+
+# Admin store (Better Auth users, sessions, signing keys): the `auth` schema of DATABASE_URL, created by `db:migrate`.
+BETTER_AUTH_URL=http://localhost:5173
+# Signs cookies and encrypts the token keys. Generate your own: openssl rand -base64 32
+BETTER_AUTH_SECRET=change-me-generate-with-openssl-rand-base64-32
+# TRUSTED_ORIGINS=

package/dist/templates/real-estate/AGENTS.md

@@ -0,0 +1,24 @@
+# Working on this app
+
+A Protobase app: each resource's data config in `config/<name>/data.ts` and its screens in `config/<name>/ui.ts`, all
+exported from `config/index.ts`, over a Postgres database. Reference: https://docs.protobase.net.
+
+## Database changes
+
+- Every schema change is a new migration file in `db/migrations/`, numbered after the last one (`007_viewings.sql`).
+  Never edit or remove a migration that exists: it has already run on the live database.
+- Expand only, where possible: add tables, columns and indexes, and keep what the running app still reads. Rename or
+  drop only when asked to, once nothing uses it.
+- A new table gets `organization_id integer not null references core.organizations (id)`, like the others; everyone
+  works in organization 1 (`auth/auth.ts`).
+
+## Never touch
+
+- `auth/` and the `auth` schema: sign-in and accounts.
+- `.github/workflows/`.
+
+## Scripts
+
+The platform runs `db:migrate` (the auth schema's migrations included), `typecheck` and `test`, with their settings in
+the environment: keep them working. Run `typecheck` and `test` before you finish. `db:seed:base` loads the amenities and organization 1,
+and `db:seed` the sample data, replacing everything in the app's tables.

package/dist/templates/real-estate/_.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+.env

package/dist/templates/real-estate/_bunfig.toml

@@ -0,0 +1,4 @@
+# `bun run` runs scripts and package bins on Bun even when Node is on PATH, whose `#!/usr/bin/env node` would otherwise
+# start Node.
+[run]
+bun = true

package/dist/templates/real-estate/auth/auth.ts

@@ -0,0 +1,36 @@
+import { PostgresDialect } from 'kysely'
+import pg from 'pg'
+import { betterAuthAuthenticator, createAuth, handleDroppedConnections } from '@protobase/server'
+import { databaseUrl } from '../db/connection'
+
+const secret = process.env.BETTER_AUTH_SECRET
+if (!secret) throw new Error('BETTER_AUTH_SECRET is not set; generate one with `openssl rand -base64 32` and put it in .env')
+
+// One pool across hot reloads of this module
+const store = globalThis as { __realEstateAdminPool?: pg.Pool }
+store.__realEstateAdminPool ??= handleDroppedConnections(new pg.Pool({ connectionString: databaseUrl, max: 5 }))
+
+/** The admin store (Better Auth's users, sessions and signing keys) lives in this schema, next to the example's own schemas. */
+export const authSchema = 'auth'
+
+const pool = store.__realEstateAdminPool
+
+// Tickets name their assignee by core.users' integer id, so a new user takes the next value of that table's sequence;
+// their row there comes with the account (db/migrations/013_auth_users.sql).
+const nextUserId = async () => {
+  const { rows } = await pool.query<{ id: string }>("select nextval(pg_get_serial_sequence('core.users', 'id'))::text as id")
+  return rows[0]!.id
+}
+
+export const auth = createAuth({
+  database: { dialect: new PostgresDialect({ pool }), type: 'postgres', schemaName: authSchema, transaction: true },
+  baseURL: process.env.BETTER_AUTH_URL ?? 'http://localhost:5173',
+  secret,
+  // No defaultRole on purpose: every account is created with an explicit role (`protobase users create --role`).
+  roles: ['admin', 'manager', 'finance', 'maintenance'],
+  generateUserId: nextUserId,
+  trustedOrigins: process.env.TRUSTED_ORIGINS?.split(',').filter(Boolean),
+})
+
+/** Organizations are not used yet: everyone works in organization 1. */
+export const authenticate = betterAuthAuthenticator({ auth, tenant: 1 })

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

@@ -0,0 +1,12 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.amenities, a reference table shared by every organization. */
+export const amenities = resource('amenities')
+  .table('portfolio.amenities')
+  .fields({
+    code: f.text().filterable().sortable(),
+    name: f.text(),
+  })
+  .primaryKey((r) => r.code)
+  .access(access('amenities'))

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

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { amenities } from './data'
+
+export const amenitiesView = view<typeof amenities>('amenities')
+  .names({ singular: 'Amenity', plural: 'Amenities' })
+  .fields((r) => ({ code: r.code.format('code') }))
+  .list((r) => ({ columns: [r.name, r.code] }))

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

@@ -0,0 +1,19 @@
+import { f, resource } from '@protobase/schema'
+import { roles } from '../roles'
+
+/**
+ * billing.arrears, a view: the leases that still owe rent, with what they owe. It reads the open charges only, through
+ * a partial index, so it stays quick however much history there is. Read-only: payments change it.
+ */
+export const arrears = resource('arrears')
+  .table('billing.arrears')
+  .fields({
+    lease_id: f.relation('leases').readOnly().filterable().sortable(),
+    organization_id: f.relation('organizations').readOnly().filterable().sortable(),
+    open_charges: f.integer().readOnly().filterable().sortable(),
+    balance: f.decimal({ precision: 12, scale: 2 }).readOnly().filterable().sortable(),
+    oldest_due_on: f.date().readOnly().filterable().sortable(),
+  })
+  .primaryKey((r) => r.lease_id)
+  .tenant((r) => r.organization_id)
+  .access({ read: roles.can('arrears.read'), create: () => false, update: () => false, delete: () => false })

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

@@ -0,0 +1,21 @@
+import { view } from '@protobase/schema'
+import type { arrears } from './data'
+
+export const arrearsView = view<typeof arrears>('arrears')
+  .names({ singular: 'Arrears', plural: 'Arrears' })
+  .help('Leases with rent outstanding: every charge minus its payments.')
+  .fields((r) => ({
+    lease_id: r.lease_id.label('Lease'),
+    open_charges: r.open_charges.label('Open months').help('Charges not yet paid in full.'),
+    balance: r.balance.label('Outstanding').prefix('€').decimals(2),
+    oldest_due_on: r.oldest_due_on.label('Oldest due'),
+  }))
+  .list((r) => ({ columns: [r.lease_id, r.balance, r.open_charges, r.oldest_due_on], sort: [[r.balance, 'desc']] }))
+  .filters((r, w) => [w.range(r.balance, { histogram: true }), w.range(r.open_charges)])
+  .actions((a) => [
+    a.action('remind', {
+      label: 'Send reminder',
+      icon: 'mail',
+      inputs: (i) => [i.text('note', { label: 'Note', help: 'Added to the mail under what is outstanding.', multiline: true, optional: true })],
+    }),
+  ])

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

@@ -0,0 +1,21 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** leasing.deposits: one per lease. */
+export const deposits = resource('deposits')
+  .table('leasing.deposits')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    lease_id: f.relation('leases').filterable().sortable(),
+    amount: f.decimal({ precision: 10, scale: 2 }),
+    received_on: f.date(),
+    status: f.enum(['held', 'returned', 'partially_returned', 'withheld']).default('held').filterable().sortable(),
+    returned_amount: f.decimal({ precision: 10, scale: 2 }).default('0'),
+    returned_on: f.date().optional(),
+    created_at: f.timestamp().readOnly().filterable().sortable().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .tenant((r) => r.organization_id)
+  .access(access('deposits'))

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

@@ -0,0 +1,17 @@
+import { l, view } from '@protobase/schema'
+import type { deposits } from './data'
+
+export const depositsView = view<typeof deposits>('deposits')
+  .names({ singular: 'Deposit', plural: 'Deposits' })
+  .fields((r) => ({
+    lease_id: r.lease_id.label('Lease'),
+    amount: r.amount.help('Usually two months of the first rent.').prefix('€').decimals(2),
+    status: r.status.help('Held while the lease runs; settled after the move-out inspection.').format('badge').valueLabels({ held: 'Held', returned: 'Returned', partially_returned: 'Partially returned', withheld: 'Withheld' }),
+    returned_amount: r.returned_amount.prefix('€').decimals(2),
+  }))
+  .list((r) => ({ columns: [r.lease_id, r.amount, r.status, r.received_on, r.returned_on, r.returned_amount] }))
+  .filters((r, w) => [w.facets(r.status)])
+  .layout((r) => [
+    l.section('Deposit', [r.lease_id, r.amount, r.received_on]),
+    l.section('Settlement', [r.status, r.returned_amount, r.returned_on], { help: 'Fill in after the move-out inspection.' }),
+  ])

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

@@ -0,0 +1,41 @@
+export { organizations } from './organizations/data'
+export { organizationsView } from './organizations/ui'
+export { users } from './users/data'
+export { usersView } from './users/ui'
+export { amenities } from './amenities/data'
+export { amenitiesView } from './amenities/ui'
+export { owners } from './owners/data'
+export { ownersView } from './owners/ui'
+export { properties } from './properties/data'
+export { propertiesView } from './properties/ui'
+export { units } from './units/data'
+export { unitsView } from './units/ui'
+export { unitAmenities } from './unit_amenities/data'
+export { unitAmenitiesView } from './unit_amenities/ui'
+export { valuations } from './valuations/data'
+export { valuationsView } from './valuations/ui'
+export { tenants } from './tenants/data'
+export { tenantsView } from './tenants/ui'
+export { leases } from './leases/data'
+export { leasesView } from './leases/ui'
+export { leaseTenants } from './lease_tenants/data'
+export { leaseTenantsView } from './lease_tenants/ui'
+export { deposits } from './deposits/data'
+export { depositsView } from './deposits/ui'
+export { rentCharges } from './rent_charges/data'
+export { rentChargesView } from './rent_charges/ui'
+export { payments } from './payments/data'
+export { paymentsView } from './payments/ui'
+export { arrears } from './arrears/data'
+export { arrearsView } from './arrears/ui'
+export { vendors } from './vendors/data'
+export { vendorsView } from './vendors/ui'
+export { tickets } from './tickets/data'
+export { ticketsView } from './tickets/ui'
+export { workOrders } from './work_orders/data'
+export { workOrdersView } from './work_orders/ui'
+export { inspections } from './inspections/data'
+export { inspectionsView } from './inspections/ui'
+export { accountMenu } from './user-menu'
+export { usersPage } from '@protobase/layout'
+export { portfolioOverview } from './overview/page'

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

@@ -0,0 +1,22 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** maintenance.inspections: at move-in, at move-out, and now and then in between. */
+export const inspections = resource('inspections')
+  .table('maintenance.inspections')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    unit_id: f.relation('units').filterable().sortable(),
+    lease_id: f.relation('leases').optional().filterable().sortable(),
+    inspector_id: f.relation('users').filterable().sortable(),
+    kind: f.enum(['move_in', 'move_out', 'periodic']).filterable().sortable(),
+    inspected_on: f.date().filterable().sortable(),
+    condition: f.enum(['good', 'fair', 'poor']).filterable().sortable(),
+    notes: 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('inspections'))

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

@@ -0,0 +1,15 @@
+import { view } from '@protobase/schema'
+import type { inspections } from './data'
+
+export const inspectionsView = view<typeof inspections>('inspections')
+  .names({ singular: 'Inspection', plural: 'Inspections' })
+  .fields((r) => ({
+    unit_id: r.unit_id.label('Unit'),
+    lease_id: r.lease_id.label('Lease'),
+    inspector_id: r.inspector_id.label('Inspector'),
+    kind: r.kind.format('badge').valueLabels({ move_in: 'Move-in', move_out: 'Move-out', periodic: 'Periodic' }),
+    inspected_on: r.inspected_on.label('Date'),
+    condition: r.condition.format('badge').valueLabels({ good: 'Good', fair: 'Fair', poor: 'Poor' }),
+  }))
+  .list((r) => ({ columns: [r.unit_id, r.kind, r.inspected_on, r.condition, r.inspector_id], sort: [[r.inspected_on, 'desc']] }))
+  .filters((r, w) => [w.facets(r.kind), w.facets(r.condition), w.dateRange(r.inspected_on, { presets: ['30d', '90d', 'year'] })])

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

@@ -0,0 +1,16 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** leasing.lease_tenants: who signed a lease, one primary tenant and any co-signers. */
+export const leaseTenants = resource('lease_tenants')
+  .table('leasing.lease_tenants')
+  .fields({
+    lease_id: f.relation('leases').filterable().sortable(),
+    tenant_id: f.relation('tenants').filterable().sortable(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    role: f.enum(['primary', 'co_signer']).filterable().sortable(),
+    added_at: f.timestamp().dbDefault(),
+  })
+  .primaryKey((r) => [r.lease_id, r.tenant_id])
+  .tenant((r) => r.organization_id)
+  .access(access('lease_tenants'))

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

@@ -0,0 +1,8 @@
+import { view } from '@protobase/schema'
+import type { leaseTenants } from './data'
+
+export const leaseTenantsView = view<typeof leaseTenants>('lease_tenants')
+  .nav({ hidden: true })
+  .names({ singular: 'Lease tenant', plural: 'Lease tenants' })
+  .fields((r) => ({ role: r.role.format('badge').valueLabels({ primary: 'Primary', co_signer: 'Co-signer' }) }))
+  .list((r) => ({ columns: [r.lease_id, r.tenant_id, r.role] }))

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

@@ -0,0 +1,29 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** leasing.leases. Unique: (organization_id, number). Postgres refuses a lease that overlaps another on its unit. */
+export const leases = resource('leases')
+  .table('leasing.leases')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    number: f.text().filterable().sortable(),
+    unit_id: f.relation('units').filterable().sortable(),
+    term: f.enum(['indefinite', 'fixed']).default('indefinite').filterable().sortable(),
+    start_date: f.date().filterable().sortable(),
+    end_date: f.date().optional().filterable().sortable(),
+    monthly_rent: f.decimal({ precision: 10, scale: 2 }),
+    service_costs: f.decimal({ precision: 10, scale: 2 }).default('0'),
+    notice_given_on: f.date().optional(),
+    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.number])
+  .validate((record) => {
+    if (record.term === 'fixed' && !record.end_date) return [{ field: 'end_date', message: 'A fixed-term lease needs an end date.' }]
+    if (record.end_date && record.start_date && record.end_date < record.start_date) return [{ field: 'end_date', message: 'The lease cannot end before it starts.' }]
+    return undefined
+  })
+  .access(access('leases'))

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

@@ -0,0 +1,33 @@
+import { l, view } from '@protobase/schema'
+import type { leases } from './data'
+
+export const leasesView = view<typeof leases>('leases')
+  .title((r) => r.number)
+  .names({ singular: 'Lease', plural: 'Leases' })
+  .fields((r) => ({
+    number: r.number.help('Assigned when the lease is signed.').format('code'),
+    unit_id: r.unit_id.label('Unit'),
+    term: r.term.help('Indefinite leases run until notice; fixed ones end on their end date.').format('badge').valueLabels({ indefinite: 'Indefinite', fixed: 'Fixed' }),
+    start_date: r.start_date.label('Start'),
+    end_date: r.end_date.label('End').help('The last day of the tenancy. Empty while an indefinite lease runs.'),
+    monthly_rent: r.monthly_rent.help('Current rent; it rises every 1 July.').prefix('€').decimals(2),
+    service_costs: r.service_costs.help('Monthly advance for shared services, billed with the rent.').prefix('€').decimals(2),
+    notice_given_on: r.notice_given_on.label('Notice given'),
+  }))
+  .list((r) => ({ columns: [r.number, r.unit_id, r.term, r.start_date, r.end_date, r.monthly_rent], sort: [[r.start_date, 'desc']], search: [r.number] }))
+  .filters((r, w) => [w.facets(r.term), w.dateRange(r.start_date, { presets: ['90d', 'year'] }), w.dateRange(r.end_date, { presets: ['90d', 'year'] })])
+  .layout((r) => [
+    l.section('Lease', [r.unit_id, r.term, r.start_date, r.end_date, r.notice_given_on]),
+    l.section('Rent', [r.monthly_rent, r.service_costs]),
+    l.related('Rent charges', {
+      resource: 'rent_charges',
+      field: 'lease_id',
+      sort: 'period desc',
+      columns: ['period', 'due_on', 'description', 'amount', 'paid_amount', 'outstanding'],
+      // a year of monthly charges
+      limit: 12,
+      empty: 'No rent charged yet.',
+    }),
+    l.sidebar([r.term, r.monthly_rent]),
+  ])
+  .saveFeedback('button')

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

@@ -0,0 +1,17 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** core.organizations. Unique: (slug) */
+export const organizations = resource('organizations')
+  .table('core.organizations')
+  .fields({
+    id: f.integer().readOnly().filterable().sortable().dbDefault(),
+    name: f.text(),
+    slug: f.text().filterable().sortable(),
+    city: f.text(),
+    kvk_number: f.text(),
+    created_at: f.timestamp().readOnly().dbDefault(),
+    updated_at: f.timestamp().readOnly().dbDefault(),
+  })
+  .primaryKey((r) => r.id)
+  .access(access('organizations'))

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

@@ -0,0 +1,7 @@
+import { view } from '@protobase/schema'
+import type { organizations } from './data'
+
+export const organizationsView = view<typeof organizations>('organizations')
+  .names({ singular: 'Organization', plural: 'Organizations' })
+  .fields((r) => ({ kvk_number: r.kvk_number.label('KvK number').help('Chamber of Commerce registration.').format('code') }))
+  .list((r) => ({ columns: [r.name, r.slug, r.city, r.kvk_number] }))

package/dist/templates/real-estate/config/overview/page.tsx

@@ -0,0 +1,57 @@
+/** @jsxImportSource @protobase/layout */
+import { Action, Card, Field, Grid, Page, RecordCard, Show, Stat, Table, page } from '@protobase/layout'
+
+/** The property manager's start page: occupancy, rent outstanding and the maintenance that is still open. */
+export const portfolioOverview = page(
+  'overview',
+  <Page title="Portfolio overview" description="Occupancy, arrears and open maintenance across the portfolio.">
+    <Show when="units.count = 0">
+      <Card title="No units yet">Add a property and its units; this page fills up as leases start.</Card>
+    </Show>
+    <Grid columns={4}>
+      <Stat label="Units" resource="units" />
+      <Stat label="Vacant" resource="units" filter="status = 'vacant'" description="Ready to let" />
+      <Stat label="Leases in arrears" resource="arrears" />
+      <Stat label="Open tickets" resource="tickets" filter="status = 'reported' OR status = 'scheduled'" />
+    </Grid>
+    <Grid columns={2}>
+      <RecordCard
+        title="Largest arrears"
+        resource="arrears"
+        sort="balance desc"
+        empty="Every tenant is paid up."
+        actions={<Action name="remind" label="Send reminder" variant="primary" />}
+      >
+        <Grid columns={2}>
+          <Field name="lease_id" label="Lease" />
+          <Field name="balance" label="Outstanding" />
+          <Field name="open_charges" label="Open months" />
+          <Field name="oldest_due_on" label="Oldest due" />
+        </Grid>
+        <Field name="lease_id.unit_id" label="Unit" />
+      </RecordCard>
+      <RecordCard
+        title="Oldest urgent ticket"
+        resource="tickets"
+        filter="priority = 'urgent' AND (status = 'reported' OR status = 'scheduled')"
+        sort="reported_at"
+        empty="No urgent tickets are open."
+        actions={<Action name="complete" variant="primary" />}
+      >
+        <Grid columns={2}>
+          <Field name="number" />
+          <Field name="status" />
+          <Field name="property_id" label="Property" />
+          <Field name="reported_at" label="Reported" />
+        </Grid>
+        <Field name="title" />
+      </RecordCard>
+    </Grid>
+    <Grid columns={2}>
+      <Table title="Arrears" resource="arrears" sort="balance desc" columns={['lease_id', 'balance', 'open_charges', 'oldest_due_on']} limit={5} empty="Every tenant is paid up." />
+      <Table title="Open tickets" resource="tickets" filter="status = 'reported' OR status = 'scheduled'" sort="reported_at desc" columns={['number', 'title', 'priority', 'status']} limit={5} empty="Nothing is open." />
+    </Grid>
+    <Table title="Vacant units" resource="units" filter="status = 'vacant'" columns={['label', 'property_id', 'bedrooms', 'base_rent']} limit={5} empty="Every unit is let." />
+  </Page>,
+  { nav: { group: 'Portfolio', order: 0 }, icon: 'layout-dashboard' },
+)

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

@@ -0,0 +1,22 @@
+import { f, resource } from '@protobase/schema'
+import { access } from '../roles'
+
+/** portfolio.owners: the landlords whose properties the firm manages. */
+export const owners = resource('owners')
+  .table('portfolio.owners')
+  .fields({
+    id: f.bigint().readOnly().filterable().sortable().dbDefault(),
+    organization_id: f.relation('organizations').filterable().sortable(),
+    name: f.text(),
+    kind: f.enum(['private', 'company', 'pension_fund', 'housing_association']).filterable().sortable(),
+    email: f.text().optional(),
+    phone: f.text().optional(),
+    iban: f.text().regex(/^[A-Z]{2}\d{2}[A-Z0-9]{10,30}$/, 'An IBAN without spaces, such as NL91ABNA0417164300'),
+    management_fee_percent: f.decimal({ precision: 4, scale: 2 }).default('6'),
+    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('owners'))

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

@@ -0,0 +1,17 @@
+import { l, view } from '@protobase/schema'
+import type { owners } from './data'
+
+export const ownersView = view<typeof owners>('owners')
+  .title((r) => r.name)
+  .names({ singular: 'Owner', plural: 'Owners' })
+  .fields((r) => ({
+    kind: r.kind.format('badge').valueLabels({ private: 'Private', company: 'Company', pension_fund: 'Pension fund', housing_association: 'Housing association' }),
+    iban: r.iban.label('IBAN').help('Where the rent, less the management fee, is paid out.').format('code'),
+    management_fee_percent: r.management_fee_percent.label('Management fee').help('Share of the collected rent the firm keeps.').format('percent'),
+  }))
+  .list((r) => ({ columns: [r.name, r.kind, r.email, r.management_fee_percent], search: [r.name] }))
+  .filters((r, w) => [w.facets(r.kind)])
+  .layout((r) => [
+    l.section('Owner', [r.name, r.kind, r.email, r.phone]),
+    l.section('Payout', [r.iban, r.management_fee_percent]),
+  ])