create-protobase 0.23.13 → 0.24.0

package/dist/templates/real-estate/seed/builders/ticket.ts

@@ -0,0 +1,115 @@
+import { DAY, windowEnd } from '../calendar'
+import type { Trade } from '../data/reference'
+import { int, pick, rngAt, weighted } from '../rng'
+import type { Org } from '../world'
+import { propertyAcquiredAt, propertyShapeAt, tenanciesOf } from './allocation'
+
+const HOUR = 3_600_000
+
+// What tenants report, the trade that fixes it, and a few ways they put it.
+const categories = {
+  heating: { weight: 20, trades: ['heating'], titles: ['Boiler shows an error code', 'No hot water', 'Radiators stay cold', 'Boiler pressure keeps dropping', 'Thermostat does not respond'] },
+  plumbing: { weight: 18, trades: ['plumbing'], titles: ['Leaking tap in the kitchen', 'Toilet keeps running', 'Blocked drain in the shower', 'Low water pressure', 'Washing machine tap leaks'] },
+  electrical: { weight: 9, trades: ['electrical'], titles: ['Group keeps tripping', 'Socket in the living room is dead', 'Doorbell broken', 'Extractor fan does not work'] },
+  leak: { weight: 8, trades: ['roofing', 'plumbing'], titles: ['Water stain on the ceiling', 'Roof leaks after rain', 'Damp coming through the wall'] },
+  mould: { weight: 7, trades: ['general'], titles: ['Mould in the bathroom', 'Black spots behind the wardrobe', 'Condensation on the windows'] },
+  locks: { weight: 6, trades: ['locksmith'], titles: ['Front door lock is stiff', 'Locked out, key broken off', 'Storage room lock broken'] },
+  appliances: { weight: 10, trades: ['electrical', 'general'], titles: ['Oven does not heat', 'Dishwasher leaks', 'Fridge is not cooling', 'Hob does not switch on'] },
+  windows_doors: { weight: 10, trades: ['carpentry'], titles: ['Window does not close', 'Balcony door sticks', 'Draught along the window frame', 'Kitchen cabinet door came off'] },
+  garden: { weight: 5, trades: ['general'], titles: ['Fence blown over', 'Shared garden overgrown', 'Tree branches over the path'] },
+  pests: { weight: 7, trades: ['pest_control'], titles: ['Mice in the kitchen', 'Wasps nest under the roof', 'Bedbugs', 'Pigeons nesting on the balcony'] },
+} satisfies Record<string, { weight: number; trades: Trade[]; titles: string[] }>
+
+type Category = keyof typeof categories
+const categoryEntries = Object.entries(categories).map(([name, spec]) => [name as Category, spec.weight] as const)
+
+// Days from report to planning, and from planning to the visit, by priority.
+const triageDays = { urgent: [0, 0], high: [0, 2], normal: [1, 5], low: [2, 10] } as const
+const leadDays = { urgent: [0, 1], high: [1, 4], normal: [4, 14], low: [10, 35] } as const
+
+// The vendors of the organization that do this trade, falling back to the handyman.
+const vendorFor = (org: Org, category: Category, rand: () => number) => {
+  const trade = pick(rand, categories[category].trades)
+  const matching = org.vendors.filter((vendor) => vendor.trade === trade)
+  return pick(rand, matching.length > 0 ? matching : org.vendors.filter((vendor) => vendor.trade === 'general'))
+}
+
+// A unit of a property that was already managed when the ticket came in.
+const unitFor = (org: Org, reportedAt: number, rand: () => number) => {
+  for (let attempt = 0; attempt < 50; attempt++) {
+    const unit = int(rand, 0, org.unitCount - 1)
+    if (propertyAcquiredAt(org.seed, org.unitProperty[unit]!) <= reportedAt) return unit
+  }
+  return int(rand, 0, org.unitCount - 1)
+}
+
+/**
+ * A ticket and its work orders, rebuilt from its ordinal. Time decides the status: a ticket not planned by the window's
+ * end is still reported, one whose last visit lies ahead is scheduled, the rest are done or (a few) cancelled.
+ */
+export const ticketAt = (org: Org, ordinal: number) => {
+  const rand = rngAt(org.seed + 13, ordinal)
+  const reportedAt = org.ticketTimes[ordinal]!
+  const unit = unitFor(org, reportedAt, rand)
+  const property = org.unitProperty[unit]!
+  const category = weighted(rand, categoryEntries)
+  const winter = [10, 11, 0, 1, 2].includes(new Date(reportedAt).getUTCMonth())
+  const priority = category === 'heating' && winter && rand() < 0.5 ? 'urgent' : weighted(rand, [['urgent', 4], ['high', 18], ['normal', 58], ['low', 20]] as const)
+  // Roofs, gardens and pests of a building are reported for the whole property.
+  const wholeProperty = propertyShapeAt(org.seed, property).kind !== 'single_family' && ['leak', 'garden', 'pests'].includes(category) && rand() < 0.4
+
+  const tenancies = tenanciesOf(org.seed, unit, propertyAcquiredAt(org.seed, property))
+  const current = tenancies.findIndex((tenancy) => tenancy.start <= reportedAt && (tenancy.end === null || tenancy.end + DAY > reportedAt))
+  const lease = current === -1 ? null : org.leaseStarts[unit]! + current
+  const reportedBy = lease === null || rand() < 0.1 ? null : org.tenantFirstId + org.tenantStarts[lease]!
+
+  const day = (ms: number) => Math.floor(ms / DAY) * DAY
+  const [triageMin, triageMax] = triageDays[priority]
+  const [leadMin, leadMax] = leadDays[priority]
+  const plannedAt = reportedAt + int(rand, triageMin, triageMax) * DAY + int(rand, 1, 6) * HOUR
+  const firstVisit = day(plannedAt) + int(rand, leadMin, leadMax) * DAY
+  const visits = rand() < 0.15 ? [firstVisit, firstVisit + int(rand, 3, 14) * DAY] : [firstVisit]
+  const cancelled = rand() < 0.06
+  const cancelledAt = reportedAt + int(rand, 1, 10) * DAY + int(rand, 1, 8) * HOUR
+
+  const status =
+    cancelled && cancelledAt <= windowEnd ? 'cancelled'
+    : cancelled || plannedAt > windowEnd ? 'reported'
+    : visits.at(-1)! + 17 * HOUR > windowEnd ? 'scheduled'
+    : 'done'
+  const workOrders = status === 'scheduled' || status === 'done'
+    ? visits.map((visit) => {
+        const vendor = vendorFor(org, category, rand)
+        const completed = visit + 17 * HOUR <= windowEnd
+        const hours = int(rand, 1, 12) / 2
+        return {
+          vendorId: vendor.id,
+          scheduledFor: visit,
+          completedOn: completed ? visit : null,
+          hours: completed ? hours : null,
+          costCents: completed ? Math.round(hours * vendor.rate * 100) + int(rand, 0, 40) * 1000 : null,
+          notes: completed && visits.length > 1 && visit === visits[0] ? 'Temporary fix, part ordered' : null,
+          createdAt: plannedAt,
+        }
+      })
+    : []
+  const closedAt = status === 'done' ? visits.at(-1)! + int(rand, 14, 17) * HOUR : status === 'cancelled' ? cancelledAt : null
+  const title = pick(rand, categories[category].titles)
+  return {
+    id: org.ticketFirstId + ordinal,
+    number: `MT-${new Date(reportedAt).getUTCFullYear()}-${String(ordinal + 1).padStart(6, '0')}`,
+    propertyId: org.propertyFirstId + property,
+    unitId: wholeProperty ? null : org.unitFirstId + unit,
+    reportedBy: wholeProperty ? null : reportedBy,
+    assignedTo: status === 'reported' && rand() < 0.5 ? null : pick(rand, org.maintenanceUsers).id,
+    category,
+    priority,
+    status,
+    title,
+    description: rand() < 0.6 ? `${title}. ${pick(rand, ['Tenant is home after 17:00.', 'Key is with the neighbours.', 'Please call before coming.', 'Started last week.', 'Second time this year.'])}` : null,
+    reportedAt,
+    closedAt,
+    workOrders,
+    updatedAt: closedAt ?? (workOrders.length > 0 ? plannedAt : reportedAt),
+  }
+}

package/dist/templates/real-estate/seed/calendar.ts

@@ -0,0 +1,77 @@
+import { makeRng, type Rand } from './rng'
+
+export const DAY = 86_400_000
+
+export const windowEnd = Date.UTC(2026, 9, 6, 9, 41)
+export const windowStart = windowEnd - 3 * 365 * DAY
+
+export const yearOf = (ms: number) => new Date(ms).getUTCFullYear()
+
+// Sunday first. Weekdays carry the traffic, Saturday a fifth, Sunday almost nothing.
+const dayShare = [0.05, 1.15, 1.1, 1.05, 1.0, 0.85, 0.2]
+
+const HOUR = 3_600_000
+
+// Time of day in ms: mostly business hours with a midday-ish peak, some early and evening traffic.
+const timeOfDay = (weekday: number, rand: Rand) => {
+  const roll = rand()
+  if (weekday === 0 || weekday === 6) return (9 + 6 * rand()) * HOUR
+  if (roll < 0.82) return (8 + (9 * (rand() + rand())) / 2) * HOUR
+  if (roll < 0.9) return (6 + 2 * rand()) * HOUR
+  return (17 + 5 * rand()) * HOUR
+}
+
+// A moment `delay` after `at`; when that would pass the end of the window, somewhere between `at` and the end.
+export const within = (at: number, delay: number, rand: Rand) => (at + delay <= windowEnd ? at + delay : at + Math.floor(rand() * (windowEnd - at)))
+
+// Ascending timestamps (ms) spread over the window: weekday/weekend pattern,
+// slow growth over three years, a quieter December and day-to-day noise.
+// Times never leave the window, and the first and last day are partial days.
+export const timestamps = (count: number, seed: number) => {
+  const rand = makeRng(seed)
+  const firstDay = Math.floor(windowStart / DAY) * DAY
+  const days = Math.ceil((windowEnd - firstDay) / DAY)
+  const bounds = (d: number) => [Math.max(firstDay + d * DAY, windowStart), Math.min(firstDay + (d + 1) * DAY, windowEnd)] as const
+  const weights = Array.from({ length: days }, (_, d) => {
+    const date = new Date(firstDay + d * DAY)
+    const [lo, hi] = bounds(d)
+    const season = date.getUTCMonth() === 11 ? 0.8 : 1
+    return dayShare[date.getUTCDay()]! * ((hi - lo) / DAY) * (0.7 + (0.3 * d) / days) * season * (0.85 + 0.3 * rand())
+  })
+  const total = weights.reduce((sum, weight) => sum + weight, 0)
+
+  const times = new Float64Array(count)
+  let assigned = 0
+  let cumulative = 0
+  for (let d = 0; d < days; d++) {
+    cumulative += weights[d]!
+    const dayCount = Math.round((count * cumulative) / total) - assigned
+    const [lo, hi] = bounds(d)
+    const day = firstDay + d * DAY
+    const weekday = new Date(day).getUTCDay()
+    const sampled = Array.from({ length: dayCount }, () => {
+      const at = Math.floor(day + timeOfDay(weekday, rand))
+      return at >= lo && at <= hi ? at : lo + Math.floor(rand() * (hi - lo))
+    }).sort((a, b) => a - b)
+    times.set(sampled, assigned)
+    assigned += dayCount
+  }
+  return times
+}
+
+// Months as the UTC midnight of their first day. Leases start on a first and end on a last day of a month.
+export const monthOf = (ms: number) => {
+  const date = new Date(ms)
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1)
+}
+
+export const addMonths = (month: number, count: number) => {
+  const date = new Date(month)
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + count, 1)
+}
+
+export const lastDayOf = (month: number) => addMonths(month, 1) - DAY
+
+/** The first rent period inside the window, and the last one (the month the window ends in). */
+export const firstPeriod = addMonths(monthOf(windowStart), 1)
+export const lastPeriod = monthOf(windowEnd)

package/dist/templates/real-estate/seed/cli.ts

@@ -0,0 +1,50 @@
+import { connect } from '../db/connection'
+import { isScale, scales } from './scales'
+import { seedBilling } from './steps/billing'
+import { seedLeasing } from './steps/leasing'
+import { seedMaintenance } from './steps/maintenance'
+import { seedPortfolio } from './steps/portfolio'
+import { seedReference } from './steps/reference'
+import { analyzeAll, createIndexes, dropIndexes, resetSequences, setTriggers, truncateAll } from './maintenance'
+import { buildWorld } from './world'
+
+const flag = process.argv.indexOf('--scale')
+const scale = flag === -1 ? 'small' : process.argv[flag + 1]
+if (!isScale(scale)) throw new Error(`Unknown scale "${scale}", expected one of: ${Object.keys(scales).join(', ')}`)
+
+const started = performance.now()
+const step = async (name: string, run: () => Promise<unknown>) => {
+  const before = performance.now()
+  await run()
+  console.log(`${name} (${((performance.now() - before) / 1000).toFixed(1)}s)`)
+}
+
+const world = buildWorld(scale)
+
+// One connection for the load, with foreign keys, check and exclusion constraints on: an app's own role may not skip
+// them (session_replication_role), only switch its triggers off, so the seed writes `paid_amount` itself. Postgres
+// still refuses an overlapping lease or an overpaid charge; tests/examples/real-estate/smoke.test.ts checks the rest.
+const loader = connect({ max: 1 })
+
+await step('truncate', () => truncateAll(loader))
+const indexes = await dropIndexes(loader)
+await setTriggers(loader, false)
+try {
+  await step('reference', () => seedReference(loader, world))
+  await step('portfolio', () => seedPortfolio(loader, world))
+  await step('leasing', () => seedLeasing(loader, world))
+  await step('billing', () => seedBilling(loader, world))
+  await step('maintenance', () => seedMaintenance(loader, world))
+} finally {
+  await setTriggers(loader, true)
+}
+await loader.end()
+
+const sql = connect({ max: 4 })
+await step('indexes', () => createIndexes(sql, indexes))
+await step('sequences', () => resetSequences(sql))
+await sql`insert into public.seed_info (scale) values (${scale})`
+await step('analyze', () => analyzeAll(sql))
+await sql.end()
+
+console.log(`seeded ${scale} in ${((performance.now() - started) / 1000).toFixed(1)}s`)

package/dist/templates/real-estate/seed/copy.ts

@@ -0,0 +1,22 @@
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import type { Db } from '../db/connection'
+
+const batchSize = 2000
+
+function* batches(rows: Iterable<string>) {
+  let batch: string[] = []
+  for (const line of rows) {
+    batch.push(line)
+    if (batch.length < batchSize) continue
+    yield batch.join('')
+    batch = []
+  }
+  if (batch.length > 0) yield batch.join('')
+}
+
+// Streams COPY text-format rows into `schema.table (columns)`.
+export const copyRows = async (sql: Db, target: string, rows: Iterable<string>) => {
+  const writable = await sql.unsafe(`copy ${target} from stdin`).writable()
+  await pipeline(Readable.from(batches(rows)), writable)
+}

package/dist/templates/real-estate/seed/data/names.ts

@@ -0,0 +1,31 @@
+export const firstNames = [
+  'Sanne', 'Daan', 'Lieke', 'Jeroen', 'Femke', 'Bram', 'Anouk', 'Ruben', 'Eva', 'Thijs', 'Noor', 'Pieter', 'Mirjam', 'Joost',
+  'Fleur', 'Lars', 'Iris', 'Sem', 'Julia', 'Luuk', 'Tess', 'Milan', 'Lotte', 'Stijn', 'Yara', 'Mohamed', 'Fatima', 'Ahmed',
+  'Sara', 'Kevin', 'Esmee', 'Niels', 'Roos', 'Wouter', 'Maaike', 'Bas', 'Ilse', 'Gijs', 'Merel', 'Koen',
+]
+
+export const surnames = [
+  'de Vries', 'van den Berg', 'Bakker', 'Janssen', 'Visser', 'Smit', 'Meijer', 'de Boer', 'Mulder', 'de Groot', 'Bos', 'Vos',
+  'Peters', 'Hendriks', 'van Dijk', 'Dekker', 'Kok', 'Jacobs', 'de Jong', 'Jansen', 'van Leeuwen', 'Willems', 'van der Meer',
+  'Brouwer', 'de Wit', 'Dijkstra', 'Smits', 'de Graaf', 'van der Linden', 'Kramer', 'Yilmaz', 'El Amrani', 'Bouzid', 'Kaya',
+  'Verhoeven', 'Postma', 'Hoekstra', 'Koster', 'Prins', 'Huisman',
+]
+
+export const streets = [
+  'Kerkstraat', 'Molenweg', 'Dorpsstraat', 'Julianalaan', 'Beatrixstraat', 'Wilhelminastraat', 'Lindenlaan', 'Eikenlaan',
+  'Parkweg', 'Schoolstraat', 'Nieuwstraat', 'Kastanjelaan', 'Prinsengracht', 'Oranjestraat', 'Stationsweg', 'Zuiderkade',
+  'Havenstraat', 'Burgemeester de Vlugtlaan', 'Rembrandtlaan', 'Vondelstraat', 'Spoorlaan', 'Brugstraat', 'Tulpstraat',
+  'Mauritsweg', 'Singel', 'Leidsestraat', 'Hoflaan', 'Van Goghstraat', 'Kanaalweg', 'Marktplein',
+]
+
+// Apartment buildings and mixed-use blocks carry a name; single-family homes are known by their address.
+export const buildingNames = [
+  'De Linde', 'Parkzicht', 'Het Baken', 'De Kade', 'Zonnehof', 'De Wilgen', 'Het Anker', 'Waterfront', 'De Meander',
+  'Oostpoort', 'De Werf', 'Lindenhof', 'Het Atrium', 'De Plataan', 'Havenkwartier', 'De Molen', 'Stadstuin', 'De Esch',
+]
+
+export const buildingPrefixes = ['Residentie', 'Complex', 'Wooncomplex', 'Appartementen']
+
+export const ownerCompanyWords = ['Vastgoed', 'Beleggingen', 'Woningen', 'Huisvesting', 'Real Estate']
+
+export const banks = ['ABNA', 'INGB', 'RABO', 'SNSB', 'TRIO', 'ASNB', 'BUNQ', 'KNAB']

package/dist/templates/real-estate/seed/data/reference.ts

@@ -0,0 +1,63 @@
+export const amenities = [
+  ['balcony', 'Balcony'], ['garden', 'Garden'], ['roof_terrace', 'Roof terrace'], ['lift', 'Lift'],
+  ['parking', 'Parking space'], ['bike_storage', 'Bike storage'], ['storage_room', 'Storage room'],
+  ['solar_panels', 'Solar panels'], ['heat_pump', 'Heat pump'], ['furnished', 'Furnished'],
+] as const
+
+export type AmenityCode = (typeof amenities)[number][0]
+
+// Where each organization lets homes: a city centre (lat/lng), its postal code range and the market rent per m2 in 2026.
+export type City = readonly [name: string, lat: number, lng: number, postalFrom: number, postalTo: number, rentPerM2: number]
+
+export const trades = ['plumbing', 'heating', 'electrical', 'roofing', 'carpentry', 'locksmith', 'pest_control', 'general'] as const
+
+export type Trade = (typeof trades)[number]
+
+export const orgSpecs = [
+  {
+    id: 1,
+    name: 'Grachtenhof Vastgoedbeheer B.V.',
+    slug: 'grachtenhof',
+    city: 'Amsterdam',
+    kvk: '34187726',
+    share: 0.7,
+    seed: 301,
+    cities: [
+      ['Amsterdam', 52.3676, 4.9041, 1011, 1109, 25], ['Haarlem', 52.3874, 4.6462, 2011, 2037, 21],
+      ['Utrecht', 52.0907, 5.1214, 3511, 3585, 22], ['Amstelveen', 52.3114, 4.8701, 1181, 1189, 23.5],
+      ['Zaandam', 52.4420, 4.8292, 1501, 1509, 18.5], ['Hilversum', 52.2292, 5.1669, 1211, 1223, 19],
+    ] as readonly City[],
+    users: [
+      ['Sanne', 'M.', 'admin'], ['Daan', 'K.', 'manager'], ['Femke', 'D.', 'manager'], ['Joost', 'R.', 'finance'],
+      ['Mirjam', 'V.', 'finance'], ['Thijs', 'W.', 'maintenance'], ['Bram', 'B.', 'maintenance'], ['Lieke', 'P.', 'manager'],
+    ] as const,
+    vendors: [
+      ['Loodgietersbedrijf De Waal', 'plumbing', 68], ['Installatietechniek Van Dam', 'heating', 74], ['Elektro Mulder', 'electrical', 65],
+      ['Dakwerken Brouwer', 'roofing', 70], ['Timmerbedrijf Kok', 'carpentry', 58], ['Slotenservice Amstel', 'locksmith', 82],
+      ['Ongediertebestrijding Noord', 'pest_control', 90], ['Klusbedrijf Jansen', 'general', 52], ['CV-Service Haarlem', 'heating', 71],
+      ['Loodgieter Vos & Zn.', 'plumbing', 64],
+    ] as const,
+  },
+  {
+    id: 2,
+    name: 'Maaskant Verhuur & Beheer B.V.',
+    slug: 'maaskant',
+    city: 'Rotterdam',
+    kvk: '24411509',
+    share: 0.3,
+    seed: 402,
+    cities: [
+      ['Rotterdam', 51.9244, 4.4777, 3011, 3089, 19.5], ['Den Haag', 52.0705, 4.3007, 2491, 2597, 20],
+      ['Delft', 52.0116, 4.3571, 2611, 2629, 20.5], ['Dordrecht', 51.8133, 4.6901, 3311, 3329, 15.5],
+      ['Schiedam', 51.9192, 4.3988, 3111, 3125, 16.5], ['Breda', 51.5719, 4.7683, 4811, 4838, 17],
+    ] as readonly City[],
+    users: [
+      ['Anouk', 'L.', 'admin'], ['Ruben', 'S.', 'manager'], ['Eva', 'H.', 'finance'], ['Pieter', 'T.', 'maintenance'], ['Noor', 'G.', 'maintenance'],
+    ] as const,
+    vendors: [
+      ['Loodgietersbedrijf Maasstad', 'plumbing', 66], ['Warmtetechniek Rijnmond', 'heating', 72], ['Elektrotechniek De Jong', 'electrical', 63],
+      ['Dakdekkersbedrijf Visser', 'roofing', 69], ['Klus & Timmerwerk Smit', 'carpentry', 55], ['Sleutelspecialist Zuid', 'locksmith', 80],
+      ['Plaagdierbeheer West', 'pest_control', 88], ['Allround Onderhoud Bakker', 'general', 50],
+    ] as const,
+  },
+] as const

package/dist/templates/real-estate/seed/format.ts

@@ -0,0 +1,24 @@
+const escapes: Record<string, string> = { '\\': '\\\\', '\t': '\\t', '\n': '\\n', '\r': '\\r' }
+
+const cell = (value: unknown) => {
+  if (value === null || value === undefined) return '\\N'
+  return String(value).replace(/[\\\t\n\r]/g, (char) => escapes[char]!)
+}
+
+// One COPY text-format row.
+export const row = (...values: unknown[]) => values.map(cell).join('\t') + '\n'
+
+export const money = (cents: number) => `${Math.floor(cents / 100)}.${String(cents % 100).padStart(2, '0')}`
+
+export const iso = (ms: number) => new Date(ms).toISOString()
+
+export const isoDate = (ms: number) => iso(ms).slice(0, 10)
+
+export const slugify = (text: string) =>
+  text
+    .normalize('NFD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/&/g, 'and')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '')

package/dist/templates/real-estate/seed/iban.ts

@@ -0,0 +1,15 @@
+import { banks } from './data/names'
+import { int, pick, type Rand } from './rng'
+
+// ISO 13616 check digits: the account with "NL00" moved to the end, letters as numbers, mod 97.
+const checkDigits = (bban: string) => {
+  const digits = `${bban}NL00`.replace(/[A-Z]/g, (letter) => String(letter.charCodeAt(0) - 55))
+  const remainder = digits.split('').reduce((rest, digit) => (rest * 10 + Number(digit)) % 97, 0)
+  return String(98 - remainder).padStart(2, '0')
+}
+
+/** A Dutch IBAN with valid check digits: NLkk BANK 0123456789. */
+export const iban = (rand: Rand) => {
+  const bban = `${pick(rand, banks)}${String(int(rand, 100_000_000, 999_999_999)).padStart(10, '0')}`
+  return `NL${checkDigits(bban)}${bban}`
+}

package/dist/templates/real-estate/seed/maintenance.ts

@@ -0,0 +1,63 @@
+import type { Db } from '../db/connection'
+
+const schemas = ['core', 'portfolio', 'leasing', 'billing', 'maintenance']
+
+export const truncateAll = async (sql: Db) => {
+  const tables = await sql`
+    select format('%I.%I', schemaname, tablename) as name from pg_tables
+    where schemaname in ${sql(schemas)} or tablename = 'seed_info'
+  `
+  await sql.unsafe(`truncate ${tables.map((table) => table.name).join(', ')} restart identity cascade`)
+}
+
+// Secondary indexes only: primary keys and unique constraints stay in place.
+const secondaryIndexes = (sql: Db) => sql`
+  select format('%I.%I', n.nspname, c.relname) as name, pg_get_indexdef(i.indexrelid) as definition
+  from pg_index i
+  join pg_class c on c.oid = i.indexrelid
+  join pg_namespace n on n.oid = c.relnamespace
+  where n.nspname in ${sql(schemas)}
+    and not i.indisprimary
+    and not exists (select 1 from pg_constraint k where k.conindid = i.indexrelid)
+`
+
+// Loading into indexed tables is several times slower than building the indexes afterwards.
+export const dropIndexes = async (sql: Db) => {
+  const indexes = await secondaryIndexes(sql)
+  for (const index of indexes) await sql.unsafe(`drop index ${index.name}`)
+  return indexes.map((index) => index.definition as string)
+}
+
+export const createIndexes = async (sql: Db, definitions: string[]) => {
+  await Promise.all(definitions.map((definition) => sql.unsafe(definition)))
+}
+
+// The triggers that keep stored totals in step with their rows. The seed writes those totals itself, and recomputing
+// them during the load, with the secondary indexes gone, takes minutes at small scale and hours above it. A table's
+// owner may switch its own triggers off, unlike the foreign key checks, which stay on.
+export const setTriggers = async (sql: Db, enabled: boolean) => {
+  const tables = await sql`
+    select distinct format('%I.%I', n.nspname, c.relname) as name
+    from pg_trigger t
+    join pg_class c on c.oid = t.tgrelid
+    join pg_namespace n on n.oid = c.relnamespace
+    where not t.tgisinternal and n.nspname in ${sql(schemas)}
+  `
+  for (const table of tables) await sql.unsafe(`alter table ${table.name} ${enabled ? 'enable' : 'disable'} trigger user`)
+}
+
+// COPY with explicit ids leaves identity sequences at 1.
+export const resetSequences = async (sql: Db) => {
+  const columns = await sql`
+    select table_schema as schema, table_name as table, column_name as column from information_schema.columns
+    where is_identity = 'YES' and table_schema in ${sql(schemas)}
+  `
+  for (const { schema, table, column } of columns) {
+    const target = `${schema}.${table}`
+    await sql.unsafe(`select setval(pg_get_serial_sequence('${target}', '${column}'), coalesce(max(${column}), 1), max(${column}) is not null) from ${target}`)
+  }
+}
+
+export const analyzeAll = async (sql: Db) => {
+  await sql.unsafe('analyze')
+}

package/dist/templates/real-estate/seed/rng.ts

@@ -0,0 +1,36 @@
+export const hash = (seed: number, index: number) => {
+  let h = (seed ^ Math.imul(index + 0x9e3779b9, 0x85ebca6b)) >>> 0
+  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b)
+  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35)
+  return (h ^ (h >>> 16)) >>> 0
+}
+
+// Independent stream per (seed, index): lets any row be rebuilt without generating its neighbours.
+export const rngAt = (seed: number, index: number) => {
+  let state = hash(seed, index)
+  return () => {
+    state = (state + 0x6d2b79f5) >>> 0
+    let t = state
+    t = Math.imul(t ^ (t >>> 15), t | 1)
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}
+
+export type Rand = ReturnType<typeof rngAt>
+
+export const pick = <T>(rand: Rand, items: readonly T[]) => items[Math.floor(rand() * items.length)]!
+
+export const int = (rand: Rand, min: number, max: number) => min + Math.floor(rand() * (max - min + 1))
+
+export const weighted = <T>(rand: Rand, entries: ReadonlyArray<readonly [T, number]>) => {
+  const total = entries.reduce((sum, [, weight]) => sum + weight, 0)
+  let roll = rand() * total
+  for (const [value, weight] of entries) {
+    roll -= weight
+    if (roll < 0) return value
+  }
+  return entries[entries.length - 1]![0]
+}
+
+export const makeRng = (seed: number) => rngAt(seed, 0)

package/dist/templates/real-estate/seed/scales.ts

@@ -0,0 +1,9 @@
+export const scales = {
+  small: { properties: 60, ticketsPerUnit: 1.2 },
+  medium: { properties: 2_000, ticketsPerUnit: 1.2 },
+  large: { properties: 10_000, ticketsPerUnit: 1.2 },
+} as const
+
+export type ScaleName = keyof typeof scales
+
+export const isScale = (name: string | undefined): name is ScaleName => name !== undefined && name in scales

package/dist/templates/real-estate/seed/steps/billing.ts

@@ -0,0 +1,44 @@
+import type { Db } from '../../db/connection'
+import { ledgerOf } from '../builders/ledger'
+import { DAY, windowEnd } from '../calendar'
+import { copyRows } from '../copy'
+import { iso, isoDate, money, row } from '../format'
+import type { World } from '../world'
+import { leasesOf } from './leasing'
+
+// Charges and payments are numbered as they stream; both passes walk the leases in the same order, so a payment
+// finds its charge's id by counting along.
+function* ledgers(world: World) {
+  let chargeId = 1
+  let paymentId = 1
+  for (const org of world.orgs) {
+    for (const lease of leasesOf(org)) {
+      for (const charge of ledgerOf(org, lease)) {
+        yield { org, lease, charge, chargeId: chargeId++, firstPaymentId: paymentId }
+        paymentId += charge.payments.length
+      }
+    }
+  }
+}
+
+function* chargeRows(world: World) {
+  for (const { org, lease, charge, chargeId } of ledgers(world)) {
+    const updatedAt = charge.payments.at(-1)?.paidOn ?? charge.createdAt
+    yield row(chargeId, org.id, lease.id, isoDate(charge.period), isoDate(charge.dueOn), charge.description, money(charge.amountCents), money(charge.paidCents), iso(charge.createdAt), iso(Math.min(updatedAt + 10 * 3_600_000, windowEnd)))
+  }
+}
+
+function* paymentRows(world: World) {
+  for (const { org, lease, charge, chargeId, firstPaymentId } of ledgers(world)) {
+    for (const [index, payment] of charge.payments.entries()) {
+      const bookedAt = Math.min(payment.paidOn + DAY / 2, windowEnd)
+      const reference = payment.method === 'direct_debit' ? `SEPA ${lease.number}` : `${lease.number} ${charge.description.toLowerCase()}`
+      yield row(firstPaymentId + index, org.id, chargeId, isoDate(payment.paidOn), money(payment.amountCents), payment.method, reference, iso(bookedAt), iso(bookedAt))
+    }
+  }
+}
+
+export const seedBilling = async (sql: Db, world: World) => {
+  await copyRows(sql, 'billing.rent_charges (id, organization_id, lease_id, period, due_on, description, amount, paid_amount, created_at, updated_at)', chargeRows(world))
+  await copyRows(sql, 'billing.payments (id, organization_id, charge_id, paid_on, amount, method, reference, created_at, updated_at)', paymentRows(world))
+}

package/dist/templates/real-estate/seed/steps/leasing.ts

@@ -0,0 +1,60 @@
+import type { Db } from '../../db/connection'
+import { tenanciesOf } from '../builders/allocation'
+import { depositFor, leaseAt, tenantsOf, type SeededLease } from '../builders/tenancy'
+import { copyRows } from '../copy'
+import { iso, isoDate, money, row } from '../format'
+import type { Org, World } from '../world'
+import { unitsOf } from './portfolio'
+
+// Every lease of the organization, in lease order (unit by unit, oldest first).
+export function* leasesOf(org: Org): Generator<SeededLease> {
+  for (const { property, unit, ordinal } of unitsOf(org)) {
+    const tenancies = tenanciesOf(org.seed, ordinal, property.createdAt)
+    for (const [index, tenancy] of tenancies.entries()) yield leaseAt(org, property, unit, ordinal, index, tenancy)
+  }
+}
+
+function* leaseRows(world: World) {
+  for (const org of world.orgs) {
+    for (const lease of leasesOf(org)) {
+      const { start, end, term } = lease.tenancy
+      yield row(lease.id, org.id, lease.number, lease.unitId, term, isoDate(start), end === null ? null : isoDate(end), money(lease.rentCents), money(lease.serviceCents), lease.notice === null ? null : isoDate(lease.notice), iso(lease.createdAt), iso(lease.updatedAt))
+    }
+  }
+}
+
+function* tenantRows(world: World) {
+  for (const org of world.orgs) {
+    for (const lease of leasesOf(org)) {
+      for (const t of tenantsOf(org, lease)) {
+        yield row(t.id, org.id, t.firstName, t.lastName, t.email, t.phone, isoDate(t.dateOfBirth), t.iban, money(t.incomeCents), iso(t.createdAt), iso(t.createdAt))
+      }
+    }
+  }
+}
+
+function* leaseTenantRows(world: World) {
+  for (const org of world.orgs) {
+    for (const lease of leasesOf(org)) {
+      for (const tenant of tenantsOf(org, lease)) yield row(lease.id, tenant.id, org.id, tenant.role, iso(lease.createdAt))
+    }
+  }
+}
+
+// One deposit per lease, so it takes the lease's id.
+function* depositRows(world: World) {
+  for (const org of world.orgs) {
+    for (const lease of leasesOf(org)) {
+      const d = depositFor(org, lease)
+      const updatedAt = d.returnedOn ?? d.receivedOn
+      yield row(lease.id, org.id, lease.id, money(d.amountCents), isoDate(d.receivedOn), d.status, money(d.returnedCents), d.returnedOn === null ? null : isoDate(d.returnedOn), iso(d.receivedOn), iso(updatedAt))
+    }
+  }
+}
+
+export const seedLeasing = async (sql: Db, world: World) => {
+  await copyRows(sql, 'leasing.leases (id, organization_id, number, unit_id, term, start_date, end_date, monthly_rent, service_costs, notice_given_on, created_at, updated_at)', leaseRows(world))
+  await copyRows(sql, 'leasing.tenants (id, organization_id, first_name, last_name, email, phone, date_of_birth, iban, monthly_income, created_at, updated_at)', tenantRows(world))
+  await copyRows(sql, 'leasing.lease_tenants (lease_id, tenant_id, organization_id, role, added_at)', leaseTenantRows(world))
+  await copyRows(sql, 'leasing.deposits (id, organization_id, lease_id, amount, received_on, status, returned_amount, returned_on, created_at, updated_at)', depositRows(world))
+}