create-protobase 0.23.13 → 0.24.0

package/dist/templates/erp/seed/data/catalogTree.ts

@@ -0,0 +1,72 @@
+type Item = readonly [name: string, priceCents: number]
+
+export const tree: ReadonlyArray<{ name: string; code: string; children: ReadonlyArray<{ name: string; items: readonly Item[] }> }> = [
+  {
+    name: 'Fasteners',
+    code: 'FST',
+    children: [
+      { name: 'Bolts', items: [['M8 hex bolt A2, 100 pcs', 1890], ['M12 hex bolt 8.8, 50 pcs', 2150], ['Countersunk screw M5, 200 pcs', 1260]] },
+      { name: 'Nuts and washers', items: [['M10 hex nut A2, 100 pcs', 1240], ['Stainless washer 8 mm, 250 pcs', 990], ['Nyloc nut M8, 100 pcs', 1175]] },
+      { name: 'Anchors', items: [['Wedge anchor M10 x 100, 20 pcs', 2480], ['Wall plug 8 mm, 200 pcs', 760]] },
+    ],
+  },
+  {
+    name: 'Electrical',
+    code: 'ELC',
+    children: [
+      { name: 'Cable management', items: [['Cable tie 300 mm, 100 pcs', 650], ['Cable gland M20, 25 pcs', 2340], ['Cable tray 100 mm, 3 m', 3890]] },
+      { name: 'Enclosures', items: [['Junction box IP65', 1480], ['Control cabinet 600 x 400', 12900]] },
+      { name: 'Lighting', items: [['LED panel 600 x 600, 40 W', 3290], ['LED high bay 150 W', 8990]] },
+    ],
+  },
+  {
+    name: 'Hydraulics',
+    code: 'HYD',
+    children: [
+      { name: 'Hoses', items: [['Hydraulic hose 1/2 in, 5 m', 8650], ['Hydraulic hose 3/4 in, 5 m', 11450]] },
+      { name: 'Couplings', items: [['Hydraulic coupling 3/8 in', 1895], ['Quick coupling 1/2 in', 2640], ['Banjo bolt M14', 540]] },
+    ],
+  },
+  {
+    name: 'Packaging',
+    code: 'PKG',
+    children: [
+      { name: 'Wrap and tape', items: [['Pallet wrap 500 mm', 740], ['Bubble wrap roll 50 m', 1990], ['Packing tape 48 mm, 6 rolls', 1380]] },
+      { name: 'Boxes', items: [['Corrugated box 400 x 300', 215], ['Corrugated box 600 x 400', 340]] },
+      { name: 'Labels', items: [['Pallet label roll 100 x 150', 1175], ['Thermal printer ribbon', 890]] },
+    ],
+  },
+  {
+    name: 'Safety',
+    code: 'PPE',
+    children: [
+      { name: 'Hand protection', items: [['Safety gloves, size L', 395], ['Cut resistant gloves, size M', 885]] },
+      { name: 'Eye and ear', items: [['Safety glasses, clear', 450], ['Ear defenders SNR 31', 1295], ['Earplugs, 200 pairs', 2290]] },
+    ],
+  },
+  {
+    name: 'Bearings and belts',
+    code: 'BRG',
+    children: [
+      { name: 'Bearings', items: [['Ball bearing 6204-2RS', 685], ['Taper roller bearing 30205', 1420], ['Pillow block UCP205', 2260]] },
+      { name: 'Belts', items: [['Timing belt HTD 5M, 600 mm', 2780], ['V-belt SPA 1250', 1360]] },
+    ],
+  },
+  {
+    name: 'Lubricants',
+    code: 'LUB',
+    children: [
+      { name: 'Grease', items: [['Grease cartridge, 400 g', 920], ['High temperature grease, 1 kg', 2150]] },
+      { name: 'Oil', items: [['Machine oil ISO 68, 5 l', 3950], ['Hydraulic oil HLP 46, 20 l', 8450], ['Cutting fluid, 10 l', 5480]] },
+    ],
+  },
+  {
+    name: 'Tools and pneumatics',
+    code: 'TLS',
+    children: [
+      { name: 'Hand tools', items: [['Drill bit set HSS, 19 pcs', 3490], ['Torque wrench 20-100 Nm', 14900], ['Angle grinder disc 125 mm, 10 pcs', 1880]] },
+      { name: 'Pneumatics', items: [['Pneumatic cylinder 40 x 100', 6120], ['Air hose PU 8 mm, 20 m', 2475]] },
+      { name: 'Pallets', items: [['Euro pallet EPAL, used', 1150], ['Roll container, galvanised', 9800]] },
+    ],
+  },
+]

package/dist/templates/erp/seed/data/layout.ts

@@ -0,0 +1,19 @@
+// Every warehouse gets 3 zones x 4 aisles x 5 bins, stored depth-first:
+// zone, then each aisle followed by its bins. Only bins hold stock.
+export const zones = 3
+export const aislesPerZone = 4
+export const binsPerAisle = 5
+
+const zoneSpan = 1 + aislesPerZone * (1 + binsPerAisle)
+
+export const locationsPerWarehouse = zones * zoneSpan
+
+export const zoneOffset = (zone: number) => zone * zoneSpan
+export const aisleOffset = (zone: number, aisle: number) => zoneOffset(zone) + 1 + aisle * (1 + binsPerAisle)
+export const binOffset = (zone: number, aisle: number, bin: number) => aisleOffset(zone, aisle) + 1 + bin
+
+export const binOffsets = Array.from({ length: zones * aislesPerZone * binsPerAisle }, (_, k) => {
+  const zone = Math.floor(k / (aislesPerZone * binsPerAisle))
+  const aisle = Math.floor(k / binsPerAisle) % aislesPerZone
+  return binOffset(zone, aisle, k % binsPerAisle)
+})

package/dist/templates/erp/seed/data/names.ts

@@ -0,0 +1,44 @@
+export const locales = {
+  NL: {
+    stems: ['Polder', 'Rijnland', 'Kuststaal', 'Delta', 'Veluwe', 'Maasvallei', 'Tulpen', 'Grachten', 'Noordzee', 'Waterland', 'Brabant', 'Zeeuwse', 'Hollandse', 'Zuiderzee', 'Amstel', 'Vechtstreek', 'Gelderse', 'Friese'],
+    nouns: ['Logistiek', 'Techniek', 'Verpakking', 'Installatie', 'Groothandel', 'Metaal', 'Bouwstoffen', 'Fietsen', 'Machinebouw', 'Transport', 'Scheepsbouw', 'Staalbouw', 'Elektro', 'Kunststof'],
+    suffix: 'B.V.',
+    cities: ['Rotterdam', 'Eindhoven', 'Utrecht', 'Zwolle', 'Breda', 'Groningen', 'Tilburg', 'Almere', 'Nijmegen', 'Arnhem', 'Enschede', 'Venlo'],
+    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'],
+    firstNames: ['Sanne', 'Daan', 'Lieke', 'Jeroen', 'Femke', 'Bram', 'Anouk', 'Ruben', 'Eva', 'Thijs', 'Noor', 'Pieter', 'Mirjam', 'Joost'],
+    andWord: 'en Zonen',
+    tld: 'nl',
+    dial: '+31',
+    vat: (n: number) => `NL${n}B01`,
+  },
+  DE: {
+    stems: ['Nordlicht', 'Eifel', 'Rhein-Main', 'Schwarzwald', 'Hansa', 'Alpen', 'Elbe', 'Bergisch', 'Ruhr', 'Isar', 'Saar', 'Harz', 'Bodensee', 'Franken', 'Westfalen', 'Mosel'],
+    nouns: ['Werkzeuge', 'Präzision', 'Maschinenbau', 'Handel', 'Elektro', 'Logistik', 'Verpackung', 'Systemtechnik', 'Metallbau', 'Antriebstechnik', 'Industriebedarf', 'Hydraulik', 'Kunststofftechnik'],
+    suffix: 'GmbH',
+    cities: ['Düsseldorf', 'Köln', 'Stuttgart', 'Hamburg', 'Münster', 'Nürnberg', 'Dortmund', 'Bremen', 'Hannover', 'Leipzig', 'Essen', 'Mannheim'],
+    surnames: ['Müller', 'Schmidt', 'Schneider', 'Fischer', 'Weber', 'Meyer', 'Wagner', 'Becker', 'Hoffmann', 'Schäfer', 'Koch', 'Richter', 'Klein', 'Wolf', 'Neumann', 'Schwarz', 'Zimmermann', 'Braun'],
+    firstNames: ['Lena', 'Felix', 'Marie', 'Jan', 'Katrin', 'Paul', 'Julia', 'Lukas', 'Anna', 'Moritz', 'Sabine', 'Stefan', 'Heike', 'Matthias'],
+    andWord: 'und Söhne',
+    tld: 'de',
+    dial: '+49',
+    vat: (n: number) => `DE${n}`,
+  },
+  GB: {
+    stems: ['Brightwater', 'Ironbridge', 'Harbour Street', 'Kestrel', 'Northgate', 'Oakfield', 'Redwood', 'Stonebridge', 'Millbrook', 'Ashford', 'Pennine', 'Thornbury', 'Greenway', 'Hartley'],
+    nouns: ['Trading', 'Supplies', 'Engineering', 'Fabrication', 'Distribution', 'Packaging', 'Industrial', 'Components', 'Tooling', 'Hydraulics', 'Fasteners'],
+    suffix: 'Ltd',
+    cities: ['Leeds', 'Bristol', 'Birmingham', 'Manchester', 'Sheffield', 'Nottingham', 'Liverpool', 'Newcastle', 'Cardiff', 'Coventry'],
+    surnames: ['Smith', 'Jones', 'Taylor', 'Brown', 'Williams', 'Wilson', 'Evans', 'Thomas', 'Roberts', 'Walker', 'Wright', 'Robinson', 'Thompson', 'Hughes', 'Harrison', 'Clarke', 'Bennett', 'Hall'],
+    firstNames: ['Oliver', 'Amelia', 'George', 'Isla', 'Harry', 'Ava', 'Jack', 'Emily', 'Thomas', 'Grace', 'James', 'Charlotte', 'William', 'Poppy'],
+    andWord: '& Sons',
+    tld: 'co.uk',
+    dial: '+44',
+    vat: (n: number) => `GB${n}`,
+  },
+} as const
+
+export type LocaleCode = keyof typeof locales
+
+export const qualifiers = ['Holding', 'Group', 'International', 'Benelux', 'Europe', 'Services', 'Solutions']
+
+export const jobTitles = ['Purchasing manager', 'Buyer', 'Operations manager', 'Warehouse lead', 'Finance controller', 'Owner', 'Procurement specialist', 'Logistics coordinator', 'Maintenance engineer', 'Office manager']

package/dist/templates/erp/seed/data/reference.ts

@@ -0,0 +1,53 @@
+export const countries = [
+  ['NL', 'Netherlands', true],
+  ['DE', 'Germany', true],
+  ['BE', 'Belgium', true],
+  ['FR', 'France', true],
+  ['AT', 'Austria', true],
+  ['PL', 'Poland', true],
+  ['IT', 'Italy', true],
+  ['ES', 'Spain', true],
+  ['DK', 'Denmark', true],
+  ['GB', 'United Kingdom', false],
+  ['CH', 'Switzerland', false],
+  ['NO', 'Norway', false],
+] as const
+
+export const currencies = [
+  ['EUR', 'Euro', '€', 2],
+  ['GBP', 'Pound sterling', '£', 2],
+  ['CHF', 'Swiss franc', 'CHF', 2],
+  ['DKK', 'Danish krone', 'kr', 2],
+  ['PLN', 'Polish zloty', 'zł', 2],
+] as const
+
+export const tagNames = [
+  ['VIP', '#7c3aed'], ['Key account', '#2563eb'], ['Slow payer', '#dc2626'], ['Reseller', '#0891b2'],
+  ['Export', '#059669'], ['Prospect', '#d97706'], ['Partner', '#4f46e5'], ['Seasonal', '#ca8a04'],
+  ['Government', '#475569'], ['Education', '#0d9488'], ['Credit hold', '#b91c1c'], ['Framework contract', '#9333ea'],
+] as const
+
+export const orgSpecs = [
+  {
+    id: 1,
+    name: 'Rijnland Industrial Supply B.V.',
+    slug: 'rijnland',
+    country: 'NL',
+    share: 0.7,
+    seed: 101,
+    locales: [['NL', 55], ['DE', 25], ['GB', 20]] as const,
+    users: [['Sanne', 'M.', 'admin'], ['Jonas', 'K.', 'sales'], ['Lieke', 'D.', 'finance'], ['Tobias', 'R.', 'warehouse'], ['Imke', 'V.', 'sales'], ['Marek', 'W.', 'warehouse'], ['Hanna', 'B.', 'finance'], ['Daan', 'P.', 'sales']] as const,
+    warehouses: [['AMS-01', 'Amsterdam main', 'Amsterdam', 'NL'], ['RTM-02', 'Rotterdam port', 'Rotterdam', 'NL'], ['DUS-01', 'Düsseldorf hub', 'Düsseldorf', 'DE'], ['ANT-03', 'Antwerp overflow', 'Antwerp', 'BE']] as const,
+  },
+  {
+    id: 2,
+    name: 'Nordlicht Werkzeuge GmbH',
+    slug: 'nordlicht',
+    country: 'DE',
+    share: 0.3,
+    seed: 202,
+    locales: [['DE', 60], ['NL', 20], ['GB', 20]] as const,
+    users: [['Katrin', 'L.', 'admin'], ['Felix', 'B.', 'sales'], ['Marie', 'S.', 'sales'], ['Jan', 'T.', 'finance'], ['Paul', 'W.', 'warehouse'], ['Lena', 'H.', 'warehouse']] as const,
+    warehouses: [['HAM-01', 'Hamburg central', 'Hamburg', 'DE'], ['MUC-01', 'München depot', 'München', 'DE'], ['VIE-01', 'Vienna cross-dock', 'Vienna', 'AT']] as const,
+  },
+] as const

package/dist/templates/erp/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/erp/seed/maintenance.ts

@@ -0,0 +1,63 @@
+import type { Db } from '../db/connection'
+
+const schemas = ['core', 'crm', 'catalog', 'sales', 'inventory', 'hr']
+
+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/erp/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/erp/seed/scales.ts

@@ -0,0 +1,9 @@
+export const scales = {
+  small: { companies: 200, orders: 2_000, moves: 20_000, productsPerOrg: 100 },
+  medium: { companies: 20_000, orders: 200_000, moves: 1_000_000, productsPerOrg: 1_000 },
+  large: { companies: 20_000, orders: 200_000, moves: 10_000_000, productsPerOrg: 1_000 },
+} 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/erp/seed/steps/catalog.ts

@@ -0,0 +1,34 @@
+import type { Db } from '../../db/connection'
+import { categories } from '../builders/categories'
+import { productAt } from '../builders/product'
+import { DAY, windowStart } from '../calendar'
+import { copyRows } from '../copy'
+import { iso, money, row } from '../format'
+import type { World } from '../world'
+
+function* categoryRows(world: World) {
+  const createdAt = iso(windowStart - 4 * 365 * DAY)
+  for (const org of world.orgs) {
+    for (const [index, category] of categories.entries()) {
+      const parentId = category.parent === null ? null : org.categoryFirstId + category.parent
+      yield row(org.categoryFirstId + index, org.id, parentId, category.name, category.slug, category.position, createdAt, createdAt)
+    }
+  }
+}
+
+function* productRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.productCount; ordinal++) {
+      const product = productAt(org, ordinal)
+      const createdAt = iso(product.createdAt)
+      const deletedAt = product.deletedAt === null ? null : iso(product.deletedAt)
+      const updatedAt = iso(Math.max(product.createdAt, product.deletedAt ?? windowStart - 30 * DAY))
+      yield row(product.id, org.id, product.categoryId, product.sku, product.name, product.description, money(product.priceCents), 'EUR', JSON.stringify(product.attributes), deletedAt === null, deletedAt, createdAt, updatedAt)
+    }
+  }
+}
+
+export const seedCatalog = async (sql: Db, world: World) => {
+  await copyRows(sql, 'catalog.categories (id, organization_id, parent_id, name, slug, position, created_at, updated_at)', categoryRows(world))
+  await copyRows(sql, 'catalog.products (id, organization_id, category_id, sku, name, description, price, currency_code, attributes, active, deleted_at, created_at, updated_at)', productRows(world))
+}

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

@@ -0,0 +1,62 @@
+import type { Db } from '../../db/connection'
+import { companyAt, peopleOf, personAt } from '../builders/company'
+import { DAY, windowEnd, within } from '../calendar'
+import { copyRows } from '../copy'
+import { tagNames } from '../data/reference'
+import { iso, row } from '../format'
+import { int, rngAt, weighted } from '../rng'
+import type { World } from '../world'
+
+function* companyRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.companyCount; ordinal++) {
+      const company = companyAt(org, ordinal)
+      const createdAt = iso(company.createdAt)
+      yield row(company.id, org.id, company.name, company.country, company.city, company.vatNumber, company.email, company.phone, company.status, createdAt, createdAt)
+    }
+  }
+}
+
+function* personRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.companyCount; ordinal++) {
+      const company = companyAt(org, ordinal)
+      for (let slot = 0; slot < peopleOf(org, ordinal); slot++) {
+        const person = personAt(org, company, ordinal, slot)
+        const createdAt = iso(person.createdAt)
+        yield row(person.id, org.id, company.id, person.first, person.last, person.email, person.phone, person.title, createdAt, createdAt)
+      }
+    }
+  }
+}
+
+function* tagRows(world: World) {
+  const createdAt = iso(windowEnd - 3 * 365 * DAY)
+  for (const org of world.orgs) {
+    for (const [index, [name, color]] of tagNames.entries()) yield row(org.tagFirstId + index, org.id, name, color, createdAt, createdAt)
+  }
+}
+
+function* companyTagRows(world: World) {
+  for (const org of world.orgs) {
+    const staff = org.users.filter((user) => user.role === 'sales' || user.role === 'admin')
+    for (let ordinal = 0; ordinal < org.companyCount; ordinal++) {
+      const rand = rngAt(org.seed + 6, ordinal)
+      const count = weighted(rand, [[0, 55], [1, 25], [2, 15], [3, 5]] as const)
+      const company = companyAt(org, ordinal)
+      const chosen = new Set<number>()
+      while (chosen.size < count) chosen.add(int(rand, 0, tagNames.length - 1))
+      for (const tag of chosen) {
+        const addedAt = within(company.createdAt, int(rand, 1, 400) * DAY + Math.floor(rand() * DAY), rand)
+        yield row(company.id, org.tagFirstId + tag, org.id, staff[int(rand, 0, staff.length - 1)]!.id, iso(addedAt))
+      }
+    }
+  }
+}
+
+export const seedCrm = async (sql: Db, world: World) => {
+  await copyRows(sql, 'crm.companies (id, organization_id, name, country_code, city, vat_number, email, phone, status, created_at, updated_at)', companyRows(world))
+  await copyRows(sql, 'crm.people (id, organization_id, company_id, first_name, last_name, email, phone, job_title, created_at, updated_at)', personRows(world))
+  await copyRows(sql, 'crm.tags (id, organization_id, name, color, created_at, updated_at)', tagRows(world))
+  await copyRows(sql, 'crm.company_tags (company_id, tag_id, organization_id, added_by, added_at)', companyTagRows(world))
+}

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

@@ -0,0 +1,26 @@
+import type { Db } from '../../db/connection'
+import { DAY, windowEnd } from '../calendar'
+import { copyRows } from '../copy'
+import { locales } from '../data/names'
+import { isoDate, money, row } from '../format'
+import { int, pick, rngAt } from '../rng'
+import { employeesPerOrg, type World } from '../world'
+
+const departments = ['SAL', 'FIN', 'WHS', 'ADM', 'PUR']
+const managers = 3
+
+function* employeeRows(world: World) {
+  for (const org of world.orgs) {
+    const locale = locales[org.country]
+    for (let k = 0; k < employeesPerOrg; k++) {
+      const rand = rngAt(org.seed + 8, k)
+      const name = `${pick(rand, locale.surnames)}, ${pick(rand, locale.firstNames)}`.toUpperCase()
+      const managerId = k < managers ? null : org.employeeFirstId + int(rand, 0, managers - 1)
+      const hired = windowEnd - int(rand, 30, 15 * 365) * DAY
+      yield row(org.employeeFirstId + k, org.id, name, pick(rand, departments), isoDate(hired), money(int(rand, 2_800_000, 9_500_000)), managerId, rand() < 0.92 ? 'Y' : 'N')
+    }
+  }
+}
+
+export const seedHr = (sql: Db, world: World) =>
+  copyRows(sql, 'hr."EMP_MASTER" ("EMP_ID", "ORGANIZATION_ID", "EMP_NAME", "DEPT_CD", "HIRE_DT", "SAL_AMT", "MGR_ID", "ACTIVE_FLG")', employeeRows(world))

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

@@ -0,0 +1,88 @@
+import type { Db } from '../../db/connection'
+import { productPriceCents } from '../builders/product'
+import { timestamps, yearOf } from '../calendar'
+import { copyRows } from '../copy'
+import { binOffsets } from '../data/layout'
+import { iso, money, row } from '../format'
+import { int, makeRng, pick, weighted } from '../rng'
+import type { Org, World } from '../world'
+
+const binsPerWarehouse = binOffsets.length
+
+// Moves are generated in time order against a running stock table, so issues and
+// transfers never take a bin below zero and the final table is the stock_levels seed.
+const createLedger = (org: Org) => {
+  const rand = makeRng(org.seed + 11)
+  const times = timestamps(org.moveCount, org.seed + 12)
+  const bins = org.warehouses.length * binsPerWarehouse
+  const stock = new Int32Array(org.productCount * bins)
+  const touched = new Uint8Array(stock.length)
+  const lastMovedAt = new Float64Array(stock.length)
+  const prices = Int32Array.from({ length: org.productCount }, (_, ordinal) => productPriceCents(ordinal))
+  const locationOf = (bin: number) => org.warehouses[Math.floor(bin / binsPerWarehouse)]!.firstLocationId + binOffsets[bin % binsPerWarehouse]!
+  const warehouseOf = (bin: number) => org.warehouses[Math.floor(bin / binsPerWarehouse)]!.id
+
+  // Each product lives in three home bins, so issues usually find stock.
+  const homeBin = (product: number) => (product * 13 + int(rand, 0, 2) * 97) % bins
+  const pickProduct = () => Math.floor(rand() ** 1.8 * org.productCount)
+
+  function* moves() {
+    let id = org.moveFirstId
+    let index = 0
+    const move = (product: number, bin: number, kind: string, quantity: number, reference: string | null, at: number, userId: number) => {
+      stock[product * bins + bin]! += quantity
+      touched[product * bins + bin] = 1
+      lastMovedAt[product * bins + bin] = at
+      return row(id++, org.id, org.productFirstId + product, warehouseOf(bin), locationOf(bin), kind, quantity, money(Math.round(prices[product]! * 0.62)), reference, iso(at), userId)
+    }
+
+    while (index < org.moveCount) {
+      const at = times[index]!
+      const userId = pick(rand, org.warehouseUsers).id
+      const product = pickProduct()
+      const bin = homeBin(product)
+      const available = stock[product * bins + bin]!
+      const wanted = weighted(rand, [['issue', 55], ['receipt', 28], ['transfer', 13], ['adjustment', 4]] as const)
+      const kind = wanted !== 'receipt' && available < 1 && wanted !== 'adjustment' ? 'receipt' : wanted
+      const orderOrdinal = Math.max(0, Math.min(org.orderCount - 1, Math.floor((index / org.moveCount) * org.orderCount) - int(rand, 0, 50)))
+
+      if (kind === 'issue') {
+        const reference = `SO-${yearOf(org.orderTimes[orderOrdinal]!)}-${String(orderOrdinal + 1).padStart(6, '0')}`
+        yield move(product, bin, kind, -Math.min(int(rand, 1, 40), available), reference, at, userId)
+        index += 1
+      } else if (kind === 'transfer' && org.moveCount - index >= 2) {
+        const quantity = Math.min(int(rand, 1, 40), available)
+        const target = (bin + 1 + int(rand, 0, bins - 2)) % bins
+        const reference = `TR-${int(rand, 1000, 9999)}`
+        yield move(product, bin, kind, -quantity, reference, at, userId)
+        yield move(product, target, kind, quantity, reference, at, userId)
+        index += 2
+      } else if (kind === 'adjustment') {
+        const size = int(rand, 1, 6)
+        yield move(product, bin, kind, rand() < 0.5 && available >= size ? -size : size, `CC-${int(rand, 100, 999)}`, at, userId)
+        index += 1
+      } else {
+        yield move(product, bin, 'receipt', int(rand, 5, 100), `PO-${int(rand, 10000, 99999)}`, at, userId)
+        index += 1
+      }
+    }
+  }
+
+  function* levels() {
+    for (let slot = 0; slot < stock.length; slot++) {
+      if (!touched[slot]) continue
+      const bin = slot % bins
+      yield row(org.productFirstId + Math.floor(slot / bins), locationOf(bin), org.id, stock[slot], iso(lastMovedAt[slot]!))
+    }
+  }
+
+  return { moves, levels }
+}
+
+export const seedLedger = async (sql: Db, world: World) => {
+  for (const org of world.orgs) {
+    const ledger = createLedger(org)
+    await copyRows(sql, 'inventory.stock_moves (id, organization_id, product_id, warehouse_id, location_id, kind, quantity, unit_cost, reference, moved_at, user_id)', ledger.moves())
+    await copyRows(sql, 'inventory.stock_levels (product_id, location_id, organization_id, quantity, updated_at)', ledger.levels())
+  }
+}

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

@@ -0,0 +1,24 @@
+import type { Db } from '../../db/connection'
+import { DAY, windowStart } from '../calendar'
+import { copyRows } from '../copy'
+import { countries, currencies } from '../data/reference'
+import { iso, row } from '../format'
+import type { World } from '../world'
+import { seedAuthOrganizations } from '../auth-organizations'
+
+export const seedReference = async (sql: Db, world: World) => {
+  const createdAt = iso(windowStart - 5 * 365 * DAY)
+  await copyRows(sql, 'core.countries (code, name, eu_member)', countries.map((country) => row(...country)))
+  await copyRows(sql, 'core.currencies (code, name, symbol, decimals)', currencies.map((currency) => row(...currency)))
+  await copyRows(
+    sql,
+    'core.organizations (id, name, slug, country_code, currency_code, created_at, updated_at)',
+    world.orgs.map((org) => row(org.id, org.name, org.slug, org.country, 'EUR', createdAt, createdAt)),
+  )
+  await seedAuthOrganizations(sql, world.orgs)
+  await copyRows(
+    sql,
+    'core.users (id, organization_id, email, name, role, active, created_at, updated_at)',
+    world.orgs.flatMap((org) => org.users.map((user) => row(user.id, org.id, user.email, user.name, user.role, true, createdAt, createdAt))),
+  )
+}

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

@@ -0,0 +1,58 @@
+import type { Db } from '../../db/connection'
+import { invoiceFor } from '../builders/invoice'
+import { orderAt } from '../builders/order'
+import { copyRows } from '../copy'
+import { iso, isoDate, money, row } from '../format'
+import type { World } from '../world'
+
+function* orderRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.orderCount; ordinal++) {
+      const order = orderAt(org, ordinal)
+      yield row(order.id, org.id, order.number, order.company.id, order.personId, order.ownerId, order.status, 'EUR', money(order.discount * 100), money(order.totalCents), order.paid, order.notes, iso(order.createdAt), iso(order.updatedAt))
+    }
+  }
+}
+
+function* orderLineRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.orderCount; ordinal++) {
+      const order = orderAt(org, ordinal)
+      for (const line of order.lines) {
+        yield row(order.id, line.lineNo, org.id, line.productId, line.description, line.quantity, money(line.unitPriceCents), iso(order.createdAt), iso(order.createdAt))
+      }
+    }
+  }
+}
+
+function* invoiceRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.orderCount; ordinal++) {
+      const order = orderAt(org, ordinal)
+      const invoice = invoiceFor(org, ordinal, order)
+      if (!invoice) continue
+      yield row(invoice.id, org.id, invoice.number, order.id, order.company.id, invoice.status, isoDate(invoice.issuedAt), isoDate(invoice.dueAt), money(invoice.vatRate * 100), money(invoice.subtotalCents), money(invoice.vatCents), money(invoice.totalCents), iso(invoice.createdAt), iso(invoice.updatedAt))
+    }
+  }
+}
+
+// Line ids leave room for nine positions per invoice; invoice lines mirror the order lines.
+function* invoiceLineRows(world: World) {
+  for (const org of world.orgs) {
+    for (let ordinal = 0; ordinal < org.orderCount; ordinal++) {
+      const order = orderAt(org, ordinal)
+      const invoice = invoiceFor(org, ordinal, order)
+      if (!invoice) continue
+      for (const line of order.lines) {
+        yield row((invoice.id - 1) * 10 + line.lineNo, invoice.id, org.id, line.lineNo, line.productId, line.description, line.quantity, money(line.unitPriceCents), iso(invoice.createdAt), iso(invoice.createdAt))
+      }
+    }
+  }
+}
+
+export const seedSales = async (sql: Db, world: World) => {
+  await copyRows(sql, 'sales.orders (id, organization_id, number, company_id, person_id, owner_id, status, currency_code, discount_percent, total, paid, notes, created_at, updated_at)', orderRows(world))
+  await copyRows(sql, 'sales.order_lines (order_id, line_no, organization_id, product_id, description, quantity, unit_price, created_at, updated_at)', orderLineRows(world))
+  await copyRows(sql, 'sales.invoices (id, organization_id, number, order_id, company_id, status, issued_at, due_at, vat_rate, subtotal, vat, total, created_at, updated_at)', invoiceRows(world))
+  await copyRows(sql, 'sales.invoice_lines (id, invoice_id, organization_id, position, product_id, description, quantity, unit_price, created_at, updated_at)', invoiceLineRows(world))
+}