@kazurolabs/psql-explorer 0.0.0-stage → 0.3.0

package/dist/explorer/seed.js

@@ -0,0 +1,1376 @@
+import { quoteIdentifier } from '../db/identifiers.js';
+import { listColumns, qualified } from './catalog.js';
+import { listForeignKeys } from './references.js';
+export class SeedError extends Error {
+}
+/** The most rows one run inserts. */
+export const MAX_SEED_ROWS = 100_000;
+/** Rows generated for a preview. */
+export const PREVIEW_ROWS = 10;
+// Postgres takes at most 65535 parameters a statement; keep well below it.
+const MAX_PARAMS = 30_000;
+const MAX_BATCH_ROWS = 1000;
+// Existing values of a referenced table that are picked from.
+const REFERENCE_SAMPLE = 5000;
+// Tries at a value not made before, for a column that must be unique.
+const UNIQUE_TRIES = 100;
+// Rows of all the "each" links put together, a run may go through.
+const MAX_COMBINATIONS = 1_000_000;
+export const seedLocales = [
+    'en',
+    'en_GB',
+    'en_US',
+    'de',
+    'es',
+    'fr',
+    'it',
+    'ja',
+    'nl',
+    'pt_BR',
+];
+export const conditionOps = [
+    'eq',
+    'ne',
+    'in',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'null',
+    'notNull',
+];
+/** Values an array holds when the plan does not say. */
+export const DEFAULT_ITEMS = { min: 1, max: 3 };
+// The most values one generated array holds.
+const MAX_ITEMS = 100;
+/** Whether a column holds arrays, e.g. "text[]" or "integer[][]". */
+export const isArrayType = (type) => type.endsWith('[]');
+/**
+ * Generators that fill a whole array themselves (or are written as they are), so an array column
+ * does not repeat them for each item.
+ */
+export const wholeArrayGenerators = new Set([
+    'default',
+    'null',
+    'constant',
+    'someOf',
+    'reference',
+    'link',
+]);
+// Generators whose value is the row's linked row's, so trying again never makes another.
+const linkedGenerators = new Set(['reference', 'link']);
+export const linkModes = ['random', 'each'];
+const number = (options, name, fallback) => {
+    const value = Number(options[name]);
+    return options[name] === undefined || options[name] === '' || !Number.isFinite(value)
+        ? fallback
+        : value;
+};
+const text = (options, name, fallback = '') => {
+    const value = options[name];
+    return value === undefined || value === '' ? fallback : String(value);
+};
+const date = (options, name, fallback) => {
+    const value = new Date(text(options, name, fallback));
+    if (Number.isNaN(value.getTime()))
+        throw new SeedError(`"${text(options, name)}" is not a date`);
+    return value;
+};
+/** A list typed one item a line, or comma separated. */
+export const listOf = (value) => value
+    .split(value.includes('\n') ? '\n' : ',')
+    .map((item) => item.trim())
+    .filter((item) => item !== '');
+// {{row.column_name}} in a template.
+const rowReference = /\{\{\s*row\.([^}\s]+)\s*\}\}/g;
+// {{link.name.column}} in a template: a column of the row the link gives this row.
+const linkReference = /\{\{\s*link\.([^.}\s]+)\.([^}\s]+)\s*\}\}/g;
+/** The columns a plan reads from its row: those its rules test and its templates name. */
+export function dependenciesOf(chosen) {
+    const found = new Set();
+    const visit = (each) => {
+        if (each.generator === 'template') {
+            for (const match of text(each.options ?? {}, 'template').matchAll(rowReference))
+                found.add(match[1]);
+        }
+    };
+    visit(chosen);
+    for (const rule of chosen.rules ?? []) {
+        found.add(rule.when.column);
+        visit(rule.then);
+    }
+    return [...found];
+}
+const truthy = {
+    t: 'true',
+    true: 'true',
+    f: 'false',
+    false: 'false',
+};
+const normal = (value) => {
+    const trimmed = value.trim();
+    return truthy[trimmed.toLowerCase()] ?? trimmed;
+};
+/** Whether a generated value meets a condition; numbers compare as numbers, else as text. */
+export function matches(condition, cell) {
+    if (condition.op === 'null')
+        return cell === null;
+    if (condition.op === 'notNull')
+        return cell !== null;
+    if (cell === null)
+        return condition.op === 'ne';
+    const given = condition.value ?? '';
+    if (condition.op === 'eq')
+        return normal(cell) === normal(given);
+    if (condition.op === 'ne')
+        return normal(cell) !== normal(given);
+    if (condition.op === 'in')
+        return listOf(given).some((item) => normal(item) === normal(cell));
+    const [left, right] = [Number(cell), Number(given)];
+    const numeric = cell.trim() !== '' && given.trim() !== '' && !Number.isNaN(left) && !Number.isNaN(right);
+    const order = numeric ? Math.sign(left - right) : cell < given ? -1 : cell > given ? 1 : 0;
+    if (condition.op === 'gt')
+        return order > 0;
+    if (condition.op === 'gte')
+        return order >= 0;
+    if (condition.op === 'lt')
+        return order < 0;
+    return order <= 0;
+}
+/**
+ * How likely each of `values` is, from the `weights` option: a number a line (or comma separated)
+ * for each value in turn, 1 where it is left out. Null when there are no weights, so every value is
+ * as likely as any other.
+ */
+export function weightsOf(options, values) {
+    const given = listOf(text(options, 'weights'));
+    if (given.length === 0)
+        return null;
+    const weights = values.map((value, i) => {
+        if (given[i] === undefined)
+            return 1;
+        const weight = Number(given[i]);
+        if (!Number.isFinite(weight) || weight < 0) {
+            throw new SeedError(`the weight of "${value}" is "${given[i]}": weights are numbers, 0 or more`);
+        }
+        return weight;
+    });
+    if (!weights.some((weight) => weight > 0)) {
+        throw new SeedError('every weight is 0: give at least one value a weight above 0');
+    }
+    return weights;
+}
+const weightsOption = {
+    name: 'weights',
+    label: 'weights (one a line, for each value in turn; 1 if left out)',
+    type: 'list',
+    default: '',
+};
+const between = (min, max) => [
+    { name: 'min', label: 'min', type: 'number', default: min },
+    { name: 'max', label: 'max', type: 'number', default: max },
+];
+const lengthOption = (fallback) => [
+    { name: 'length', label: 'length', type: 'number', default: fallback },
+];
+const special = 'Special';
+const definitions = [
+    { id: 'default', label: 'Column default', group: special, make: () => undefined },
+    { id: 'null', label: 'NULL', group: special, make: () => null },
+    {
+        id: 'constant',
+        label: 'Fixed value',
+        group: special,
+        options: [{ name: 'value', label: 'value', type: 'text', default: '' }],
+        make: ({ options }) => text(options, 'value'),
+    },
+    {
+        id: 'oneOf',
+        label: 'One of a list',
+        group: special,
+        options: [{ name: 'values', label: 'values', type: 'list', default: '' }, weightsOption],
+        make: ({ faker, options }) => {
+            const values = listOf(text(options, 'values'));
+            if (values.length === 0)
+                throw new SeedError('"One of a list" needs at least one value');
+            const weights = weightsOf(options, values);
+            if (!weights)
+                return faker.helpers.arrayElement(values);
+            return faker.helpers.weightedArrayElement(values.map((value, i) => ({ value, weight: weights[i] })).filter(({ weight }) => weight > 0));
+        },
+    },
+    {
+        id: 'someOf',
+        label: 'Some of a list',
+        group: special,
+        options: [
+            { name: 'values', label: 'values', type: 'list', default: '' },
+            { name: 'min', label: 'min picked', type: 'number', default: 1 },
+            { name: 'max', label: 'max picked', type: 'number', default: 3 },
+            weightsOption,
+        ],
+        make: ({ faker, options }) => {
+            const values = listOf(text(options, 'values'));
+            if (values.length === 0)
+                throw new SeedError('"Some of a list" needs at least one value');
+            const weights = weightsOf(options, values);
+            // A value of weight 0 is never picked.
+            const pickable = weights ? weights.filter((weight) => weight > 0).length : values.length;
+            const min = Math.max(0, Math.min(number(options, 'min', 1), pickable));
+            const max = Math.max(min, Math.min(number(options, 'max', 3), pickable));
+            let picked;
+            if (!weights)
+                picked = new Set(faker.helpers.arrayElements(values, { min, max }));
+            else {
+                // Weighted picks without putting back: each pick is from the values not picked yet.
+                const left = values.map((value, i) => ({ value, weight: weights[i] }));
+                picked = new Set();
+                for (let count = faker.number.int({ min, max }); picked.size < count;) {
+                    const value = faker.helpers.weightedArrayElement(left.filter((each) => each.weight > 0 && !picked.has(each.value)));
+                    picked.add(value);
+                }
+            }
+            // Distinct values, in the order the list gives them.
+            return values.filter((value) => picked.has(value));
+        },
+    },
+    {
+        id: 'reference',
+        label: 'Existing row it references',
+        group: special,
+        // Prepared into the link of its column's foreign key and the column the key points at.
+        make: ({ options, linked }) => linked(text(options, 'link'), text(options, 'column')),
+    },
+    {
+        id: 'link',
+        label: 'Column of a linked table',
+        group: special,
+        options: [
+            { name: 'link', label: 'link', type: 'text', default: '' },
+            { name: 'column', label: 'column', type: 'text', default: '' },
+        ],
+        make: ({ options, linked }) => linked(text(options, 'link'), text(options, 'column')),
+    },
+    {
+        id: 'sequence',
+        label: 'Counting up',
+        group: special,
+        options: [
+            { name: 'start', label: 'start', type: 'number', default: 1 },
+            { name: 'step', label: 'step', type: 'number', default: 1 },
+        ],
+        make: ({ options, index }) => number(options, 'start', 1) + index * number(options, 'step', 1),
+    },
+    {
+        id: 'sequenceInGroup',
+        label: 'Counting up for each linked row',
+        group: special,
+        options: [
+            { name: 'start', label: 'start', type: 'number', default: 1 },
+            { name: 'step', label: 'step', type: 'number', default: 1 },
+        ],
+        // Starts again for each row of the "each" links, e.g. line numbers 1, 2, 3 of each order.
+        make: ({ options, indexInGroup }) => number(options, 'start', 1) + indexInGroup * number(options, 'step', 1),
+    },
+    {
+        id: 'template',
+        label: 'Template',
+        group: special,
+        options: [
+            {
+                name: 'template',
+                label: 'template',
+                type: 'text',
+                default: '{{person.firstName}}-{{number.int(99)}}',
+            },
+        ],
+        make: ({ faker, options, row, linked }) => {
+            try {
+                // {{row.name}} is the value of another column, and {{link.name.column}} one of a linked
+                // row; they are put in after Faker has filled in the rest, so a value that happens to
+                // hold braces is never run as a template.
+                const values = [];
+                const hold = (value) => {
+                    values.push(value);
+                    return `\uE000${values.length - 1}\uE000`;
+                };
+                const template = text(options, 'template')
+                    .replace(linkReference, (_, link, column) => hold(linked(link, column)))
+                    .replace(rowReference, (_, name) => hold(row[name] ?? null));
+                return faker.helpers
+                    .fake(template)
+                    .replace(/\uE000(\d+)\uE000/g, (_, i) => values[Number(i)] ?? '');
+            }
+            catch (error) {
+                throw new SeedError(`the template failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        },
+    },
+    {
+        id: 'person.firstName',
+        label: 'First name',
+        group: 'Person',
+        make: ({ faker }) => faker.person.firstName(),
+    },
+    {
+        id: 'person.lastName',
+        label: 'Last name',
+        group: 'Person',
+        make: ({ faker }) => faker.person.lastName(),
+    },
+    {
+        id: 'person.fullName',
+        label: 'Full name',
+        group: 'Person',
+        make: ({ faker }) => faker.person.fullName(),
+    },
+    {
+        id: 'internet.username',
+        label: 'Username',
+        group: 'Person',
+        make: ({ faker }) => faker.internet.username(),
+    },
+    {
+        id: 'internet.email',
+        label: 'Email',
+        group: 'Person',
+        make: ({ faker }) => faker.internet.email().toLowerCase(),
+    },
+    {
+        id: 'phone.number',
+        label: 'Phone number',
+        group: 'Person',
+        make: ({ faker }) => faker.phone.number(),
+    },
+    {
+        id: 'person.jobTitle',
+        label: 'Job title',
+        group: 'Person',
+        make: ({ faker }) => faker.person.jobTitle(),
+    },
+    { id: 'person.sex', label: 'Sex', group: 'Person', make: ({ faker }) => faker.person.sex() },
+    { id: 'person.bio', label: 'Bio', group: 'Person', make: ({ faker }) => faker.person.bio() },
+    {
+        id: 'date.birthdate',
+        label: 'Birth date',
+        group: 'Person',
+        options: between(18, 80),
+        make: ({ faker, options }) => faker.date.birthdate({
+            mode: 'age',
+            min: number(options, 'min', 18),
+            max: number(options, 'max', 80),
+        }),
+    },
+    {
+        id: 'location.streetAddress',
+        label: 'Street address',
+        group: 'Location',
+        make: ({ faker }) => faker.location.streetAddress(),
+    },
+    { id: 'location.city', label: 'City', group: 'Location', make: ({ faker }) => faker.location.city() },
+    {
+        id: 'location.state',
+        label: 'State',
+        group: 'Location',
+        make: ({ faker }) => faker.location.state(),
+    },
+    {
+        id: 'location.zipCode',
+        label: 'Postcode',
+        group: 'Location',
+        make: ({ faker }) => faker.location.zipCode(),
+    },
+    {
+        id: 'location.country',
+        label: 'Country',
+        group: 'Location',
+        make: ({ faker }) => faker.location.country(),
+    },
+    {
+        id: 'location.countryCode',
+        label: 'Country code',
+        group: 'Location',
+        make: ({ faker }) => faker.location.countryCode(),
+    },
+    {
+        id: 'location.latitude',
+        label: 'Latitude',
+        group: 'Location',
+        make: ({ faker }) => faker.location.latitude(),
+    },
+    {
+        id: 'location.longitude',
+        label: 'Longitude',
+        group: 'Location',
+        make: ({ faker }) => faker.location.longitude(),
+    },
+    {
+        id: 'location.timeZone',
+        label: 'Time zone',
+        group: 'Location',
+        make: ({ faker }) => faker.location.timeZone(),
+    },
+    {
+        id: 'company.name',
+        label: 'Company name',
+        group: 'Business',
+        make: ({ faker }) => faker.company.name(),
+    },
+    {
+        id: 'company.catchPhrase',
+        label: 'Catch phrase',
+        group: 'Business',
+        make: ({ faker }) => faker.company.catchPhrase(),
+    },
+    {
+        id: 'commerce.productName',
+        label: 'Product name',
+        group: 'Business',
+        make: ({ faker }) => faker.commerce.productName(),
+    },
+    {
+        id: 'commerce.department',
+        label: 'Department',
+        group: 'Business',
+        make: ({ faker }) => faker.commerce.department(),
+    },
+    {
+        id: 'commerce.price',
+        label: 'Price',
+        group: 'Business',
+        options: between(1, 1000),
+        make: ({ faker, options }) => faker.commerce.price({ min: number(options, 'min', 1), max: number(options, 'max', 1000) }),
+    },
+    {
+        id: 'finance.currencyCode',
+        label: 'Currency code',
+        group: 'Business',
+        make: ({ faker }) => faker.finance.currencyCode(),
+    },
+    {
+        id: 'finance.accountNumber',
+        label: 'Account number',
+        group: 'Business',
+        make: ({ faker }) => faker.finance.accountNumber(),
+    },
+    { id: 'internet.url', label: 'URL', group: 'Internet', make: ({ faker }) => faker.internet.url() },
+    {
+        id: 'internet.domainName',
+        label: 'Domain name',
+        group: 'Internet',
+        make: ({ faker }) => faker.internet.domainName(),
+    },
+    {
+        id: 'internet.ipv4',
+        label: 'IPv4 address',
+        group: 'Internet',
+        make: ({ faker }) => faker.internet.ipv4(),
+    },
+    {
+        id: 'internet.ipv6',
+        label: 'IPv6 address',
+        group: 'Internet',
+        make: ({ faker }) => faker.internet.ipv6(),
+    },
+    {
+        id: 'internet.mac',
+        label: 'MAC address',
+        group: 'Internet',
+        make: ({ faker }) => faker.internet.mac(),
+    },
+    {
+        id: 'internet.userAgent',
+        label: 'User agent',
+        group: 'Internet',
+        make: ({ faker }) => faker.internet.userAgent(),
+    },
+    {
+        id: 'image.avatar',
+        label: 'Avatar URL',
+        group: 'Internet',
+        make: ({ faker }) => faker.image.avatar(),
+    },
+    { id: 'image.url', label: 'Image URL', group: 'Internet', make: ({ faker }) => faker.image.url() },
+    {
+        id: 'color.rgb',
+        label: 'Colour (#hex)',
+        group: 'Internet',
+        make: ({ faker }) => faker.color.rgb(),
+    },
+    { id: 'lorem.word', label: 'Word', group: 'Text', make: ({ faker }) => faker.lorem.word() },
+    {
+        id: 'lorem.words',
+        label: 'Words',
+        group: 'Text',
+        options: [{ name: 'count', label: 'words', type: 'number', default: 3 }],
+        make: ({ faker, options }) => faker.lorem.words(number(options, 'count', 3)),
+    },
+    {
+        id: 'lorem.sentence',
+        label: 'Sentence',
+        group: 'Text',
+        make: ({ faker }) => faker.lorem.sentence(),
+    },
+    {
+        id: 'lorem.paragraphs',
+        label: 'Paragraphs',
+        group: 'Text',
+        options: [{ name: 'count', label: 'paragraphs', type: 'number', default: 1 }],
+        make: ({ faker, options }) => faker.lorem.paragraphs(number(options, 'count', 1)),
+    },
+    { id: 'lorem.slug', label: 'Slug', group: 'Text', make: ({ faker }) => faker.lorem.slug() },
+    {
+        id: 'string.alpha',
+        label: 'Letters',
+        group: 'Text',
+        options: lengthOption(8),
+        make: ({ faker, options }) => faker.string.alpha(number(options, 'length', 8)),
+    },
+    {
+        id: 'string.alphanumeric',
+        label: 'Letters and digits',
+        group: 'Text',
+        options: lengthOption(10),
+        make: ({ faker, options }) => faker.string.alphanumeric(number(options, 'length', 10)),
+    },
+    {
+        id: 'string.numeric',
+        label: 'Digits',
+        group: 'Text',
+        options: lengthOption(6),
+        make: ({ faker, options }) => faker.string.numeric(number(options, 'length', 6)),
+    },
+    { id: 'string.uuid', label: 'UUID', group: 'Text', make: ({ faker }) => faker.string.uuid() },
+    { id: 'string.nanoid', label: 'Nano ID', group: 'Text', make: ({ faker }) => faker.string.nanoid() },
+    {
+        id: 'json.object',
+        label: 'JSON object',
+        group: 'Text',
+        options: [{ name: 'keys', label: 'keys', type: 'number', default: 3 }],
+        make: ({ faker, options }) => Object.fromEntries(Array.from({ length: number(options, 'keys', 3) }, () => [
+            faker.lorem.word(),
+            faker.lorem.words(2),
+        ])),
+    },
+    {
+        id: 'number.int',
+        label: 'Whole number',
+        group: 'Numbers',
+        options: between(0, 1000),
+        make: ({ faker, options }) => faker.number.int({ min: number(options, 'min', 0), max: number(options, 'max', 1000) }),
+    },
+    {
+        id: 'number.float',
+        label: 'Decimal number',
+        group: 'Numbers',
+        options: [
+            ...between(0, 1000),
+            { name: 'fractionDigits', label: 'decimals', type: 'number', default: 2 },
+        ],
+        make: ({ faker, options }) => faker.number.float({
+            min: number(options, 'min', 0),
+            max: number(options, 'max', 1000),
+            fractionDigits: number(options, 'fractionDigits', 2),
+        }),
+    },
+    {
+        id: 'datatype.boolean',
+        label: 'True or false',
+        group: 'Numbers',
+        options: [{ name: 'percent', label: '% true', type: 'number', default: 50 }],
+        make: ({ faker, options }) => faker.datatype.boolean(number(options, 'percent', 50) / 100),
+    },
+    {
+        id: 'date.past',
+        label: 'Past date',
+        group: 'Dates',
+        options: [{ name: 'years', label: 'years back', type: 'number', default: 1 }],
+        make: ({ faker, options }) => faker.date.past({ years: number(options, 'years', 1) }),
+    },
+    {
+        id: 'date.recent',
+        label: 'Recent date',
+        group: 'Dates',
+        options: [{ name: 'days', label: 'days back', type: 'number', default: 30 }],
+        make: ({ faker, options }) => faker.date.recent({ days: number(options, 'days', 30) }),
+    },
+    {
+        id: 'date.future',
+        label: 'Future date',
+        group: 'Dates',
+        options: [{ name: 'years', label: 'years ahead', type: 'number', default: 1 }],
+        make: ({ faker, options }) => faker.date.future({ years: number(options, 'years', 1) }),
+    },
+    {
+        id: 'date.between',
+        label: 'Date between',
+        group: 'Dates',
+        options: [
+            { name: 'from', label: 'from', type: 'date', default: '2020-01-01' },
+            { name: 'to', label: 'to', type: 'date', default: '2025-12-31' },
+        ],
+        make: ({ faker, options }) => faker.date.between({
+            from: date(options, 'from', '2020-01-01'),
+            to: date(options, 'to', '2025-12-31'),
+        }),
+    },
+];
+const byId = new Map(definitions.map((generator) => [generator.id, generator]));
+/** Every generator, for the picker: no functions, so it can be sent as JSON. */
+export const generators = definitions.map(({ id, label, group, options }) => ({
+    id,
+    label,
+    group,
+    ...(options ? { options } : {}),
+}));
+const plan = (generator, options) => options ? { generator, options } : { generator };
+// Column names (with _ and case ignored) and what usually goes in them; first match wins.
+const byName = [
+    [/^(e?mail|emailaddress|.*email)$/, plan('internet.email')],
+    [/^(first|given)name$|^fname$/, plan('person.firstName')],
+    [/^(last|family|sur)name$|^lname$/, plan('person.lastName')],
+    [/^(full|display|contact|customer)?name$/, plan('person.fullName')],
+    [/^(user|login|nick|screen)name$|^handle$/, plan('internet.username')],
+    [/phone|mobile|^tel/, plan('phone.number')],
+    [/^(job)?title$/, plan('lorem.words', { count: 4 })],
+    [/jobtitle|position|role$/, plan('person.jobTitle')],
+    [/^(gender|sex)$/, plan('person.sex')],
+    [/^(bio|about)$/, plan('person.bio')],
+    [/^(dob|birth(date|day)|dateofbirth)$/, plan('date.birthdate')],
+    [/(street|address(line)?\d?)$/, plan('location.streetAddress')],
+    [/city|town/, plan('location.city')],
+    [/^(state|province|region|county)$/, plan('location.state')],
+    [/zip|post(al)?code/, plan('location.zipCode')],
+    [/countrycode/, plan('location.countryCode')],
+    [/country/, plan('location.country')],
+    [/^lat(itude)?$/, plan('location.latitude')],
+    [/^(lng|lon|long|longitude)$/, plan('location.longitude')],
+    [/timezone|^tz$/, plan('location.timeZone')],
+    [/company|organi[sz]ation|employer|^org$/, plan('company.name')],
+    [/product/, plan('commerce.productName')],
+    [/department/, plan('commerce.department')],
+    [/price|amount|cost|total|balance|fee/, plan('commerce.price')],
+    [/currency/, plan('finance.currencyCode')],
+    [/avatar/, plan('image.avatar')],
+    [/image|photo|picture|thumbnail/, plan('image.url')],
+    [/url|website|link|homepage/, plan('internet.url')],
+    [/domain/, plan('internet.domainName')],
+    [/ip(address)?$/, plan('internet.ipv4')],
+    [/useragent/, plan('internet.userAgent')],
+    [/colou?r/, plan('color.rgb')],
+    [/slug/, plan('lorem.slug')],
+    [/description|notes?$|comment|body|content|summary|message/, plan('lorem.paragraphs')],
+    [/^(sku|code|reference|ref)$/, plan('string.alphanumeric', { length: 10 })],
+];
+const baseType = (type) => type
+    .replace(/\[\]$/, '')
+    .replace(/\(.*\)/, '')
+    .trim();
+/** The length limit of a varchar(n) or char(n) column. */
+export const maxLengthOf = (type) => {
+    const match = /^(character varying|varchar|character|char|bpchar)\((\d+)\)/.exec(type);
+    return match ? Number(match[2]) : undefined;
+};
+/** A generator that suits a column's type alone. */
+function byType(type, allowedValues) {
+    if (allowedValues?.length)
+        return plan('oneOf', { values: allowedValues.join('\n') });
+    const base = baseType(type);
+    if (base === 'boolean')
+        return plan('datatype.boolean');
+    if (base === 'smallint')
+        return plan('number.int', { min: 0, max: 1000 });
+    if (base === 'integer' || base === 'bigint')
+        return plan('number.int', { min: 0, max: 100000 });
+    if (['numeric', 'real', 'double precision', 'money'].includes(base))
+        return plan('number.float');
+    if (base.startsWith('timestamp') || base === 'date')
+        return plan('date.past');
+    if (base.startsWith('time'))
+        return plan('date.recent');
+    if (base === 'uuid')
+        return plan('string.uuid');
+    if (base === 'inet' || base === 'cidr')
+        return plan('internet.ipv4');
+    if (base === 'macaddr')
+        return plan('internet.mac');
+    if (base === 'json' || base === 'jsonb')
+        return plan('json.object');
+    if (base === 'character' || base === 'char' || base === 'bpchar') {
+        return plan('string.alpha', { length: maxLengthOf(type) ?? 1 });
+    }
+    if (base === 'text' || base === 'character varying' || base === 'varchar' || base === 'citext') {
+        return plan('lorem.words');
+    }
+    return plan('null');
+}
+const isNumericType = (type) => ['smallint', 'integer', 'bigint', 'numeric', 'real', 'double precision'].includes(baseType(type));
+const isTextType = (type) => ['text', 'character varying', 'varchar', 'citext', 'character', 'char'].includes(baseType(type));
+/** The generator a column most likely wants, from its keys, default, type and name. */
+export function suggestPlan(column, 
+// False for a plan that always writes a value, e.g. for a column given conditions.
+{ keepDefault = true } = {}) {
+    if (keepDefault && (column.generated || column.identity))
+        return plan('default');
+    // Serials, gen_random_uuid(), now() and the like fill themselves in.
+    if (keepDefault &&
+        column.default !== null &&
+        (column.primaryKey || /nextval\(|uuid|now\(\)|current_/i.test(column.default))) {
+        return plan('default');
+    }
+    if (column.references)
+        return { generator: 'reference', ...(column.unique ? { unique: true } : {}) };
+    const unique = column.primaryKey || column.unique;
+    const fromType = byType(column.type, column.allowedValues);
+    let chosen = fromType;
+    if (isTextType(column.type) && !column.allowedValues) {
+        const name = column.name.toLowerCase().replace(/[_\s-]/g, '');
+        const match = byName.find(([pattern]) => pattern.test(name));
+        if (match)
+            chosen = match[1];
+        // char(2) and the like hold codes, not names.
+        const limit = maxLengthOf(column.type);
+        if (limit !== undefined && limit <= 3 && chosen.generator === 'location.country') {
+            chosen = plan('location.countryCode');
+        }
+    }
+    else if (isNumericType(column.type) &&
+        /price|amount|cost|total|balance|fee/i.test(column.name)) {
+        chosen = plan('number.float', { min: 1, max: 1000, fractionDigits: 2 });
+    }
+    else if (keepDefault &&
+        /^(created|updated|modified|deleted)(_?at|_?on)?$/i.test(column.name) &&
+        column.default !== null) {
+        chosen = plan('default');
+    }
+    if (isArrayType(column.type) && !wholeArrayGenerators.has(chosen.generator)) {
+        // An array of allowed values picks several of them; an array of text holds single words.
+        if (chosen.generator === 'oneOf')
+            chosen = { ...chosen, generator: 'someOf' };
+        else if (chosen.generator === 'lorem.words')
+            chosen = { ...plan('lorem.word'), items: DEFAULT_ITEMS };
+        else
+            chosen = { ...chosen, items: DEFAULT_ITEMS };
+    }
+    // A nullable column with a default nobody would pick (e.g. a constant) keeps its default.
+    if (keepDefault && chosen.generator === 'null' && !column.nullable && column.default !== null)
+        chosen = plan('default');
+    if (unique && chosen.generator !== 'default') {
+        // Mostly-unique generators for keys that must not repeat.
+        if (chosen.generator === 'number.int')
+            chosen = plan('sequence');
+        return { ...chosen, unique: true };
+    }
+    return chosen;
+}
+/**
+ * The values of a one-column `CHECK (status IN ('a', 'b'))`, which Postgres shows as
+ * `CHECK ((status = ANY (ARRAY['a'::text, 'b'::text])))`; null for any other check.
+ */
+export function checkListOf(definition) {
+    const match = definition &&
+        /^CHECK \(+[^()]*?(?:\)::\w+)? = ANY \(+ARRAY\[(.*)\](?:\)::[\w\s[\]]+)?\)+$/.exec(definition);
+    if (!match || / (AND|OR) /.test(definition))
+        return null;
+    const values = [...match[1].matchAll(/'((?:[^']|'')*)'(?:::[\w\s]+)?/g)].map((item) => item[1].replaceAll("''", "'"));
+    return values.length > 0 ? values : null;
+}
+/** The table's columns with what the seeder needs to know about each, and a suggested plan. */
+export async function describeSeedColumns(session, table) {
+    const columns = await listColumns(session, table);
+    const extra = await session.rows(`SELECT a.attname AS name, a.attidentity AS identity, a.attgenerated AS generated,
+			(SELECT json_agg(e.enumlabel ORDER BY e.enumsortorder) FROM pg_catalog.pg_enum e
+				WHERE e.enumtypid IN (a.atttypid, t.typelem, t.typbasetype))::text AS enum_values,
+			(SELECT pg_catalog.pg_get_constraintdef(c.oid) FROM pg_catalog.pg_constraint c
+				WHERE c.conrelid = a.attrelid AND c.contype = 'c' AND c.conkey = ARRAY[a.attnum]
+					AND pg_catalog.pg_get_constraintdef(c.oid) LIKE '%= ANY (%ARRAY[%'
+				ORDER BY c.conname LIMIT 1) AS check_list
+		FROM pg_catalog.pg_attribute a
+		JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+		WHERE a.attrelid = $1::regclass AND a.attnum > 0 AND NOT a.attisdropped`, [qualified(table)]);
+    const found = new Map(extra.map((row) => [row.name, row]));
+    return columns.map((column) => {
+        const row = found.get(column.name);
+        const seedColumn = {
+            ...column,
+            identity: row?.identity === 'a' ? 'always' : row?.identity === 'd' ? 'default' : null,
+            generated: !!row?.generated,
+            allowedValues: row?.enum_values
+                ? JSON.parse(row.enum_values)
+                : checkListOf(row?.check_list ?? null),
+        };
+        return {
+            ...seedColumn,
+            suggestion: suggestPlan(seedColumn),
+            valueSuggestion: suggestPlan(seedColumn, { keepDefault: false }),
+        };
+    });
+}
+const pad = (value, size = 2) => String(value).padStart(size, '0');
+/** A generated value as the text Postgres reads for a column of this type; null for NULL. */
+export function toCell(value, type) {
+    if (value === null || value === undefined)
+        return null;
+    if (isArrayType(type)) {
+        const element = type.slice(0, -2);
+        // Text that already reads as an array, such as a fixed value of '{a,b}', is kept as it is.
+        if (typeof value === 'string' && value.trimStart().startsWith('{'))
+            return value;
+        const items = Array.isArray(value) ? value : [value];
+        return `{${items.map((item) => arrayItem(toCell(item, element))).join(',')}}`;
+    }
+    const base = baseType(type);
+    let cell;
+    if (value instanceof Date) {
+        if (base === 'date') {
+            cell = `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
+        }
+        else if (base.startsWith('time') && !base.startsWith('timestamp')) {
+            cell = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+        }
+        else
+            cell = value.toISOString();
+    }
+    else if (typeof value === 'object')
+        cell = JSON.stringify(value);
+    else
+        cell = String(value);
+    const limit = maxLengthOf(type);
+    return limit !== undefined && cell.length > limit ? cell.slice(0, limit) : cell;
+}
+/** One value of an array literal: NULL, or quoted so commas, braces and quotes survive. */
+const arrayItem = (cell) => cell === null ? 'NULL' : `"${cell.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+/** How many values an array plan asks for, kept within sense. */
+export function itemsOf(chosen) {
+    const clamp = (value, fallback) => Number.isFinite(value) ? Math.min(Math.max(Math.floor(value), 0), MAX_ITEMS) : fallback;
+    const min = clamp(chosen.items?.min, DEFAULT_ITEMS.min);
+    return { min, max: Math.max(min, clamp(chosen.items?.max, Math.max(min, DEFAULT_ITEMS.max))) };
+}
+/** Rows made for each row of the "each" links when the request does not say. */
+export const DEFAULT_PER_ROW = { min: 1, max: 1 };
+/** How many rows each row of the "each" links gets, kept within sense. */
+export function perRowOf(request) {
+    const clamp = (value, fallback) => Number.isFinite(value) ? Math.min(Math.max(Math.floor(value), 0), MAX_SEED_ROWS) : fallback;
+    const min = clamp(request.perRow?.min, DEFAULT_PER_ROW.min);
+    return { min, max: Math.max(min, clamp(request.perRow?.max, min)) };
+}
+// Thrown by makeCell when a unique column has no new value for this row and rows may be skipped.
+class OutOfUniqueValues extends Error {
+}
+const tableName = (table) => `${table.schema}.${table.name}`;
+const columnNames = (names) => names.map((name) => `"${name}"`).join(', ');
+/** The link a plan reads `column` of, which then loads that column. */
+function linkFor(links, name, link, column) {
+    const found = links.get(link);
+    if (!found)
+        throw new SeedError(`"${name}" reads the link "${link}", and there is no such link`);
+    if (!column)
+        throw new SeedError(`"${name}": pick a column of ${tableName(found.table)}`);
+    if (!found.columns.has(column))
+        found.columns.set(column, found.columns.size);
+    return found;
+}
+/**
+ * Checks one plan against its column; a `reference` becomes a read of its foreign key's link, at
+ * the column the key points at.
+ */
+function preparePlan(column, chosen, keys, links) {
+    const generator = byId.get(chosen.generator);
+    if (!generator)
+        throw new SeedError(`"${column.name}": no generator "${chosen.generator}"`);
+    if (generator.id === 'null' && !column.nullable) {
+        throw new SeedError(`"${column.name}" cannot be NULL`);
+    }
+    let resolved = chosen;
+    if (generator.id === 'reference') {
+        const key = keys.find((each) => each.fromColumns.includes(column.name));
+        if (!key)
+            throw new SeedError(`"${column.name}" has no foreign key to take values from`);
+        const target = key.toColumns[key.fromColumns.indexOf(column.name)];
+        resolved = { ...chosen, options: { link: key.name, column: target } };
+    }
+    const options = resolved.options ?? {};
+    if (linkedGenerators.has(generator.id)) {
+        const link = linkFor(links, column.name, text(options, 'link'), text(options, 'column'));
+        // A column that must be unique takes a row of the link no other row has.
+        if (chosen.unique && link.mode === 'random')
+            link.unique = true;
+    }
+    if (generator.id === 'template') {
+        for (const [, link, name] of text(options, 'template').matchAll(linkReference))
+            linkFor(links, column.name, link, name);
+    }
+    return { generator, plan: resolved };
+}
+/** Reads the columns plans use of a link's table: a sample to pick from, or every row for "each". */
+async function loadLink(session, link, columns, 
+// Rows that need a row of their own when the link is unique.
+count) {
+    const names = [...link.columns.keys()];
+    const read = names.map((name) => `s.${quoteIdentifier(name)}`);
+    // A foreign key can only point at a row whose key columns are all set.
+    const where = link.key
+        ? ` WHERE ${link.key.toColumns.map((name) => `s.${quoteIdentifier(name)} IS NOT NULL`).join(' AND ')}`
+        : '';
+    const list = read.length > 0 ? read.map((each) => `${each}::text`).join(', ') : 'NULL';
+    const sql = link.mode === 'each'
+        ? `SELECT ${list} FROM ${qualified(link.table)} s${where}${read.length > 0 ? ` ORDER BY ${read.join(', ')}` : ''} LIMIT ${MAX_COMBINATIONS + 1}`
+        : `SELECT DISTINCT ${list} FROM ${qualified(link.table)} s${where} LIMIT ${REFERENCE_SAMPLE}`;
+    try {
+        link.rows = (await session.run(sql)).rows;
+    }
+    catch (error) {
+        throw new SeedError(`the link "${link.name}" to ${tableName(link.table)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const from = link.key ? columnNames(link.key.fromColumns) : `the link "${link.name}"`;
+    if (link.rows.length === 0) {
+        if (link.mode === 'each') {
+            throw new SeedError(`${tableName(link.table)} has no rows to make rows for: seed it first`);
+        }
+        const nullable = link.key?.fromColumns.every((name) => columns.find((each) => each.name === name)?.nullable) ??
+            false;
+        if (!nullable) {
+            throw new SeedError(`${from} points at ${tableName(link.table)}, which has no rows yet: seed that table first`);
+        }
+        link.rows = [names.map(() => null)];
+    }
+    if (link.unique && link.rows.length < count) {
+        throw new SeedError(`${from} must be unique but ${tableName(link.table)} has only ${link.rows.length} rows to point at`);
+    }
+}
+/**
+ * Checks every plan against the table, loads the links they read, and puts the columns in an order
+ * where each comes after the columns its rules and templates read.
+ */
+async function prepare(session, table, columns, request) {
+    for (const name of Object.keys(request.columns)) {
+        if (!columns.some((column) => column.name === name))
+            throw new SeedError(`no column "${name}"`);
+    }
+    const keys = (await listForeignKeys(session, table)).outgoing;
+    const links = new Map();
+    const newLink = (name, to, key) => ({
+        name,
+        table: to,
+        mode: 'random',
+        unique: false,
+        ...(key ? { key } : {}),
+        columns: new Map(),
+        rows: [],
+        used: 0,
+    });
+    for (const key of keys)
+        links.set(key.name, newLink(key.name, key.to, key));
+    for (const asked of request.links ?? []) {
+        let link = links.get(asked.name);
+        if (link && !link.key)
+            throw new SeedError(`there are two links called "${asked.name}"`);
+        if (!link) {
+            if (!asked.schema || !asked.table) {
+                throw new SeedError(`the link "${asked.name}" needs a table`);
+            }
+            link = newLink(asked.name, { schema: asked.schema, name: asked.table });
+            links.set(asked.name, link);
+        }
+        link.mode = asked.mode ?? 'random';
+        link.unique = link.mode === 'random' && asked.unique === true;
+    }
+    const each = [...links.values()].filter((link) => link.mode === 'each');
+    const prepared = [];
+    for (const column of columns) {
+        const chosen = request.columns[column.name] ?? { generator: 'default' };
+        const rules = chosen.rules ?? [];
+        if (chosen.generator === 'default' && rules.length === 0)
+            continue;
+        if (column.generated) {
+            throw new SeedError(`"${column.name}" is a generated column, so it keeps its default`);
+        }
+        if (chosen.generator === 'default' || rules.some((rule) => rule.then.generator === 'default')) {
+            throw new SeedError(`"${column.name}" has conditions, so every case needs a generator: pick NULL or a fixed value instead of the column default`);
+        }
+        const base = preparePlan(column, chosen, keys, links);
+        const prepRules = [];
+        for (const rule of rules) {
+            if (rule.when.column === column.name) {
+                throw new SeedError(`"${column.name}" has a condition on itself`);
+            }
+            prepRules.push({ when: rule.when, use: preparePlan(column, rule.then, keys, links) });
+        }
+        prepared.push({ column, base, rules: prepRules, seen: new Set() });
+    }
+    // Rows may be skipped, so a unique link may have fewer rows than asked for; with "each" links
+    // the number of rows is not known yet, and running out is found as rows are made.
+    const needed = request.skipDuplicates || each.length > 0 ? 0 : request.count;
+    for (const link of links.values()) {
+        if (link.mode === 'each' || link.columns.size > 0)
+            await loadLink(session, link, columns, needed);
+    }
+    const index = new Map(prepared.map((each, i) => [each.column.name, i]));
+    const order = [];
+    const state = new Map();
+    const visit = (i, path) => {
+        if (state.get(i) === 'done')
+            return;
+        const name = prepared[i].column.name;
+        if (state.get(i) === 'visiting') {
+            throw new SeedError(`these columns depend on each other: ${[...path, name].join(' → ')}`);
+        }
+        state.set(i, 'visiting');
+        for (const needed of dependenciesOf(prepared[i].base.plan)) {
+            const at = index.get(needed);
+            if (at === undefined) {
+                throw new SeedError(columns.some((column) => column.name === needed)
+                    ? `"${name}" depends on "${needed}", which keeps its column default, so its value is not known: give it a generator`
+                    : `"${name}" depends on "${needed}", which is not a column`);
+            }
+            visit(at, [...path, name]);
+        }
+        state.set(i, 'done');
+        order.push(i);
+    };
+    prepared.forEach((_, i) => visit(i, []));
+    return {
+        columns: prepared,
+        order,
+        skipDuplicates: request.skipDuplicates === true,
+        links,
+        each,
+        perRow: perRowOf(request),
+    };
+}
+/** How many rows a run makes: the count asked for, or `perRow` for each row of the "each" links. */
+function layout(faker, plan, count) {
+    if (plan.each.length === 0)
+        return { total: count };
+    const combinations = plan.each.reduce((product, link) => product * link.rows.length, 1);
+    const names = plan.each.map((link) => tableName(link.table)).join(' × ');
+    if (combinations > MAX_COMBINATIONS) {
+        throw new SeedError(`${names} make ${combinations.toLocaleString('en')} combinations, more than ${MAX_COMBINATIONS.toLocaleString('en')}`);
+    }
+    const { min, max } = plan.perRow;
+    const sizes = Array.from({ length: combinations }, () => min === max ? min : faker.number.int({ min, max }));
+    const total = sizes.reduce((sum, size) => sum + size, 0);
+    if (total < 1 || total > MAX_SEED_ROWS) {
+        throw new SeedError(`that makes ${total.toLocaleString('en')} rows for ${combinations.toLocaleString('en')} rows of ${names}; a run makes 1 to ${MAX_SEED_ROWS.toLocaleString('en')}`);
+    }
+    const group = new Int32Array(total);
+    const inGroup = new Int32Array(total);
+    let at = 0;
+    sizes.forEach((size, combination) => {
+        for (let i = 0; i < size; i++, at++) {
+            group[at] = combination;
+            inGroup[at] = i;
+        }
+    });
+    return { total, group, inGroup };
+}
+function makeCell(faker, { column, base, rules, seen }, { index, indexInGroup, linked, row }, skipDuplicates) {
+    const { generator, plan: chosen } = rules.find(({ when }) => matches(when, row[when.column] ?? null))?.use ?? base;
+    const nulls = column.nullable ? Math.min(Math.max(chosen.nulls ?? 0, 0), 100) : 0;
+    if (nulls > 0 && faker.number.float({ min: 0, max: 100 }) < nulls)
+        return null;
+    const context = { faker, options: chosen.options ?? {}, index, indexInGroup, linked, row };
+    for (let attempt = 0;; attempt++) {
+        let value;
+        try {
+            if (isArrayType(column.type) && !wholeArrayGenerators.has(generator.id)) {
+                const { min, max } = itemsOf(chosen);
+                value = Array.from({ length: faker.number.int({ min, max }) }, () => generator.make(context));
+            }
+            else
+                value = generator.make(context);
+        }
+        catch (error) {
+            if (error instanceof SeedError || error instanceof OutOfUniqueValues)
+                throw error;
+            throw new SeedError(`"${column.name}": ${generator.label} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const cell = toCell(value, column.type);
+        // Unique across the whole column, whichever of its plans made the value; makeRow adds it
+        // to seen once the whole row is made.
+        if (!base.plan.unique || cell === null || !seen.has(cell))
+            return cell;
+        // A linked row's value stays the same however often it is asked for.
+        const linkedValue = linkedGenerators.has(generator.id);
+        if (attempt >= UNIQUE_TRIES || linkedValue) {
+            if (skipDuplicates)
+                throw new OutOfUniqueValues();
+            throw new SeedError(linkedValue
+                ? `"${column.name}" must be unique, but its linked rows repeat ${cell}: make the link unique, or skip rows that run out of unique values`
+                : `"${column.name}" must be unique, but ${generator.label} ran out of new values after ${seen.size}: pick one with more variety`);
+        }
+    }
+}
+/** The row of a link a new row reads, picked the first time the row reads the link. */
+function pickRow(faker, link, skipDuplicates) {
+    if (!link.unique)
+        return faker.number.int({ min: 0, max: link.rows.length - 1 });
+    link.order ??= faker.helpers.shuffle(Array.from(link.rows, (_, i) => i));
+    if (link.used < link.order.length)
+        return link.order[link.used];
+    if (skipDuplicates)
+        throw new OutOfUniqueValues();
+    throw new SeedError(`every row of ${tableName(link.table)} has been picked once, and the link "${link.name}" is unique`);
+}
+/**
+ * One row, its columns made in dependency order and returned in table order; null when a unique
+ * column ran out of new values and the plan skips such rows.
+ */
+function makeRow(faker, plan, rows, index) {
+    const { columns, order, skipDuplicates, links } = plan;
+    const picked = new Map();
+    if (rows.group) {
+        // The row's combination of rows of the "each" links, the last link counting fastest.
+        let combination = rows.group[index];
+        for (const link of plan.each.toReversed()) {
+            picked.set(link, combination % link.rows.length);
+            combination = Math.floor(combination / link.rows.length);
+        }
+    }
+    const linked = (name, column) => {
+        const link = links.get(name);
+        if (!link)
+            throw new SeedError(`there is no link "${name}"`);
+        let at = picked.get(link);
+        if (at === undefined) {
+            at = pickRow(faker, link, skipDuplicates);
+            picked.set(link, at);
+        }
+        return link.rows[at][link.columns.get(column)] ?? null;
+    };
+    const row = {};
+    const context = { index, indexInGroup: rows.inGroup?.[index] ?? index, linked, row };
+    const cells = new Array(columns.length);
+    for (const i of order) {
+        let cell;
+        try {
+            cell = makeCell(faker, columns[i], context, skipDuplicates);
+        }
+        catch (error) {
+            if (error instanceof OutOfUniqueValues)
+                return null;
+            throw error;
+        }
+        row[columns[i].column.name] = cell;
+        cells[i] = cell;
+    }
+    // Only a row that is kept uses up its values, and its rows of unique links.
+    columns.forEach(({ base, seen }, i) => {
+        if (base.plan.unique)
+            seen.add(cells[i]);
+    });
+    for (const link of picked.keys())
+        if (link.unique)
+            link.used++;
+    return cells;
+}
+/** Makes up to `size` rows from `index` on, leaving out the ones that were skipped. */
+function makeRows(faker, plan, rows, index, size) {
+    const made = [];
+    for (let i = 0; i < size; i++) {
+        const row = makeRow(faker, plan, rows, index + i);
+        if (row)
+            made.push(row);
+    }
+    return made;
+}
+async function fakerFor(request) {
+    const { allFakers } = await import('@faker-js/faker');
+    const faker = allFakers[request.locale ?? 'en'];
+    // Generating is synchronous, so a shared instance is never seeded by two runs at once.
+    faker.seed(request.seed ?? Math.floor(Math.random() * 2 ** 31));
+    return faker;
+}
+const literal = (value) => (value === null ? 'NULL' : `'${value.replaceAll("'", "''")}'`);
+function insertSql(table, prepared, rows, skipConflicts) {
+    const names = prepared.map(({ column }) => quoteIdentifier(column.name)).join(', ');
+    const overriding = prepared.some(({ column }) => column.identity === 'always')
+        ? ' OVERRIDING SYSTEM VALUE'
+        : '';
+    const width = prepared.length;
+    const values = Array.from({ length: rows }, (_, row) => `(${prepared.map((_, i) => `$${row * width + i + 1}`).join(', ')})`).join(', ');
+    return `INSERT INTO ${qualified(table)} (${names})${overriding} VALUES ${values}${skipConflicts ? ' ON CONFLICT DO NOTHING' : ''}`;
+}
+const checkCount = (count) => {
+    if (!Number.isInteger(count) || count < 1 || count > MAX_SEED_ROWS) {
+        throw new SeedError(`the number of rows is a whole number from 1 to ${MAX_SEED_ROWS.toLocaleString('en')}`);
+    }
+};
+const display = (table, prepared, row, skipConflicts) => prepared.length === 0
+    ? `INSERT INTO ${qualified(table)} DEFAULT VALUES`
+    : insertSql(table, prepared, 1, skipConflicts).replace(/VALUES \(.*\)/, `VALUES (${row.map(literal).join(', ')})`);
+/** Generates the first rows a run would insert, without inserting anything. */
+export async function previewSeed(session, table, request) {
+    checkCount(request.count);
+    const columns = await describeSeedColumns(session, table);
+    const plan = await prepare(session, table, columns, request);
+    const prepared = plan.columns;
+    const faker = await fakerFor(request);
+    const made = layout(faker, plan, request.count);
+    const shown = Math.min(made.total, PREVIEW_ROWS);
+    const rows = makeRows(faker, plan, made, 0, shown);
+    return {
+        columns: prepared.map(({ column }) => column.name),
+        rows,
+        skipped: shown - rows.length,
+        total: made.total,
+        sql: display(table, prepared, rows[0] ?? [], request.skipConflicts),
+    };
+}
+/** Generates and inserts the rows in one transaction: all of them, or none when anything fails. */
+export async function runSeed(session, table, request) {
+    checkCount(request.count);
+    const started = performance.now();
+    const columns = await describeSeedColumns(session, table);
+    const plan = await prepare(session, table, columns, request);
+    const prepared = plan.columns;
+    const faker = await fakerFor(request);
+    const made = layout(faker, plan, request.count);
+    const batch = Math.max(1, Math.min(MAX_BATCH_ROWS, Math.floor(MAX_PARAMS / Math.max(prepared.length, 1))));
+    let inserted = 0;
+    let skipped = 0;
+    let first;
+    await session.run('BEGIN');
+    try {
+        for (let done = 0; done < made.total; done += batch) {
+            const size = Math.min(batch, made.total - done);
+            if (prepared.length === 0) {
+                for (let i = 0; i < size; i++) {
+                    const result = await session.run(`INSERT INTO ${qualified(table)} DEFAULT VALUES`);
+                    inserted += result.rowCount ?? 0;
+                }
+                continue;
+            }
+            const rows = makeRows(faker, plan, made, done, size);
+            skipped += size - rows.length;
+            if (rows.length === 0)
+                continue;
+            first ??= rows[0];
+            const result = await session.run(insertSql(table, prepared, rows.length, request.skipConflicts), rows.flat());
+            inserted += result.rowCount ?? 0;
+        }
+        await session.run('COMMIT');
+    }
+    catch (error) {
+        await session.run('ROLLBACK').catch(() => undefined);
+        throw error;
+    }
+    return {
+        inserted,
+        requested: made.total,
+        skipped,
+        durationMs: performance.now() - started,
+        sql: display(table, prepared, first ?? [], request.skipConflicts),
+    };
+}
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+// Conditions one column may have.
+const MAX_RULES = 20;
+// Links one request may name.
+const MAX_LINKS = 20;
+function parseLinks(raw) {
+    if (!Array.isArray(raw) || raw.length > MAX_LINKS) {
+        throw new SeedError(`links is a list of up to ${MAX_LINKS} {"name", "schema"?, "table"?, "mode"?, "unique"?}`);
+    }
+    return raw.map((link) => {
+        if (!isRecord(link) || typeof link.name !== 'string' || !link.name.trim()) {
+            throw new SeedError('a link needs a name');
+        }
+        const mode = linkModes.find((known) => known === link.mode);
+        if (link.mode !== undefined && !mode) {
+            throw new SeedError(`the link "${link.name}": mode is ${linkModes.join(' or ')}`);
+        }
+        return {
+            name: link.name,
+            ...(typeof link.schema === 'string' && link.schema ? { schema: link.schema } : {}),
+            ...(typeof link.table === 'string' && link.table ? { table: link.table } : {}),
+            ...(mode ? { mode } : {}),
+            ...(link.unique === true ? { unique: true } : {}),
+        };
+    });
+}
+/** One plan as sent, without its rules. */
+function parsePlan(name, raw) {
+    if (!isRecord(raw) || typeof raw.generator !== 'string') {
+        throw new SeedError(`"${name}" needs a generator`);
+    }
+    const options = {};
+    if (raw.options !== undefined) {
+        if (!isRecord(raw.options))
+            throw new SeedError(`"${name}": options is {name: value}`);
+        for (const [key, value] of Object.entries(raw.options)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                options[key] = value;
+            }
+        }
+    }
+    const nulls = Number(raw.nulls);
+    let items;
+    if (raw.items !== undefined) {
+        if (!isRecord(raw.items))
+            throw new SeedError(`"${name}": items is {"min", "max"}`);
+        items = itemsOf({
+            generator: raw.generator,
+            items: { min: Number(raw.items.min), max: Number(raw.items.max) },
+        });
+    }
+    return {
+        generator: raw.generator,
+        options,
+        ...(Number.isFinite(nulls) && nulls > 0 ? { nulls } : {}),
+        ...(raw.unique === true ? { unique: true } : {}),
+        ...(items ? { items } : {}),
+    };
+}
+function parseCondition(name, raw) {
+    const op = isRecord(raw) ? conditionOps.find((known) => known === raw.op) : undefined;
+    if (!isRecord(raw) || typeof raw.column !== 'string' || !raw.column || !op) {
+        throw new SeedError(`"${name}": a condition is {"column", "op": ${conditionOps.join(' | ')}, "value"?}`);
+    }
+    if (op === 'null' || op === 'notNull')
+        return { column: raw.column, op };
+    return {
+        column: raw.column,
+        op,
+        value: raw.value === undefined || raw.value === null ? '' : String(raw.value),
+    };
+}
+/** A request body as sent by the Seed page, checked; throws a SeedError saying what is wrong. */
+export function parseSeedRequest(body) {
+    if (!isRecord(body) || !isRecord(body.columns)) {
+        throw new SeedError('send {"count", "columns": {name: {"generator", "options"?, "nulls"?, "unique"?}}}');
+    }
+    const count = Number(body.count);
+    checkCount(count);
+    const columns = {};
+    for (const [name, raw] of Object.entries(body.columns)) {
+        const chosen = parsePlan(name, raw);
+        let rules;
+        if (isRecord(raw) && raw.rules !== undefined) {
+            if (!Array.isArray(raw.rules))
+                throw new SeedError(`"${name}": rules is a list of {"when", "then"}`);
+            if (raw.rules.length > MAX_RULES)
+                throw new SeedError(`"${name}" has more than ${MAX_RULES} conditions`);
+            rules = raw.rules.map((rule) => {
+                if (!isRecord(rule))
+                    throw new SeedError(`"${name}": a rule is {"when", "then"}`);
+                return { when: parseCondition(name, rule.when), then: parsePlan(name, rule.then) };
+            });
+        }
+        columns[name] = rules?.length ? { ...chosen, rules } : chosen;
+    }
+    const seed = Number(body.seed);
+    const locale = seedLocales.find((known) => known === body.locale);
+    return {
+        count,
+        columns,
+        ...(body.seed !== undefined && body.seed !== '' && Number.isInteger(seed) ? { seed } : {}),
+        ...(locale ? { locale } : {}),
+        ...(body.skipConflicts === true ? { skipConflicts: true } : {}),
+        ...(body.skipDuplicates === true ? { skipDuplicates: true } : {}),
+        ...(body.links !== undefined ? { links: parseLinks(body.links) } : {}),
+        ...(isRecord(body.perRow)
+            ? { perRow: perRowOf({ perRow: { min: Number(body.perRow.min), max: Number(body.perRow.max) } }) }
+            : {}),
+    };
+}