@ganju/utils 0.0.15 → 0.0.17

package/dist/dataIdentifiers.d.ts

@@ -0,0 +1,8 @@
+export declare const DATA_IDENTIFIER_PATTERN: RegExp;
+export declare const DATA_SYSTEM_COLUMNS: readonly ["id", "created_at", "updated_at"];
+export declare const DATA_HIDDEN_COLUMNS: readonly ["version", "created_by", "updated_by", "participant_id"];
+export type IdentifierKind = 'table' | 'column';
+export declare const identifierIssue: (name: unknown, kind: IdentifierKind) => string | null;
+export declare const isValidIdentifier: (name: unknown, kind: IdentifierKind) => boolean;
+export declare const quoteIdentifier: (name: string) => string;
+//# sourceMappingURL=dataIdentifiers.d.ts.map

package/dist/dataIdentifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataIdentifiers.d.ts","sourceRoot":"","sources":["../src/dataIdentifiers.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,uBAAuB,QAA2B,CAAC;AAGhE,eAAO,MAAM,mBAAmB,6CAA8C,CAAC;AAE/E,eAAO,MAAM,mBAAmB,oEAKtB,CAAC;AAKX,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,QAAQ,CAAC;AAGhD,eAAO,MAAM,eAAe,GAC1B,MAAM,OAAO,EACb,MAAM,cAAc,KACnB,MAAM,GAAG,IA6BX,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,MAAM,OAAO,EAAE,MAAM,cAAc,YAC/B,CAAC;AAIvC,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAAqB,CAAC"}

package/dist/dataIdentifiers.js

@@ -0,0 +1,55 @@
+"use strict";
+// Table and column names an owner may use. Every name reaches SQL quoted, so
+// SQL keywords are fine ("order" is a natural column); what is refused is
+// what would collide with SQLite's own names or ours: a table name is also the
+// prefix of its search table, and `__` is kept for those.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteIdentifier = exports.isValidIdentifier = exports.identifierIssue = exports.DATA_HIDDEN_COLUMNS = exports.DATA_SYSTEM_COLUMNS = exports.DATA_IDENTIFIER_PATTERN = void 0;
+exports.DATA_IDENTIFIER_PATTERN = /^[a-z][a-z0-9_]{0,62}$/;
+// Columns every table has, set by the database, never by a caller.
+exports.DATA_SYSTEM_COLUMNS = ['id', 'created_at', 'updated_at'];
+// Kept on every row and never shown to the assistant.
+exports.DATA_HIDDEN_COLUMNS = [
+    'version',
+    'created_by',
+    'updated_by',
+    'participant_id'
+];
+// Names SQLite gives a meaning of its own.
+const SQLITE_ALIASES = new Set(['rowid', 'oid', '_rowid_']);
+// Why `name` can't be used, or null when it can.
+const identifierIssue = (name, kind) => {
+    if (typeof name !== 'string' || name.length === 0) {
+        return `A ${kind} needs a name.`;
+    }
+    if (!exports.DATA_IDENTIFIER_PATTERN.test(name)) {
+        return `"${name}" isn't a valid ${kind} name: use lowercase letters, digits and _, starting with a letter, up to 63 characters.`;
+    }
+    if (name.includes('__')) {
+        return `"${name}": two underscores in a row are reserved.`;
+    }
+    if (name.startsWith('sqlite_') || name.startsWith('_ganju_')) {
+        return `"${name}" is a reserved name.`;
+    }
+    // Tables share one namespace with indexes and triggers, which we name
+    // ix_<table>_<column>, ux_… and tr_….
+    if (kind === 'table' && /^(ix|ux|tr)_\d/.test(name)) {
+        return `"${name}" looks like one of the database's own index names; pick another table name.`;
+    }
+    if (SQLITE_ALIASES.has(name)) {
+        return `"${name}" is reserved by SQLite; pick another ${kind} name (e.g. "${name}_ref").`;
+    }
+    if (kind === 'column' &&
+        (exports.DATA_SYSTEM_COLUMNS.includes(name) ||
+            exports.DATA_HIDDEN_COLUMNS.includes(name))) {
+        return `"${name}" is a column every table already has.`;
+    }
+    return null;
+};
+exports.identifierIssue = identifierIssue;
+const isValidIdentifier = (name, kind) => (0, exports.identifierIssue)(name, kind) === null;
+exports.isValidIdentifier = isValidIdentifier;
+// Only ever called with a name that passed identifierIssue, or with one of
+// our own (`_ganju_*`, system columns); the quotes keep keywords inert.
+const quoteIdentifier = (name) => `"${name}"`;
+exports.quoteIdentifier = quoteIdentifier;

package/dist/dataImport.d.ts

@@ -0,0 +1,79 @@
+import { type DataColumn, type DataColumnInput, type DataColumnType, type DataTable } from './dataTypes';
+export { identifierIssue, isValidIdentifier } from './dataIdentifiers';
+export { toTableInput } from './dataTypes';
+export type ImportCell = string | number | boolean | null | undefined;
+export type ImportRow = ImportCell[];
+export declare const DATA_IMPORT_SAMPLE_ROWS = 200;
+export declare const DATA_IMPORT_BATCH = 500;
+export type DecimalMark = '.' | ',';
+/**
+ * The decimal mark a file's numbers use, from the values that can only be
+ * read one way ("12,5", "1.234.567", "1,234.50"). Undefined when none of
+ * them say, or they disagree evenly: each "28.000" is then flagged.
+ */
+export declare const detectDecimalMark: (rows: ImportRow[]) => DecimalMark | undefined;
+export interface ParsedNumber {
+    value: number;
+    ambiguous: boolean;
+}
+/**
+ * A number as a sheet writes it, with its thousands separators:
+ * "28.000" → 28000 and "1.234,50" → 1234.5 with a "," mark. A value is
+ * thousands-separated when the same separator repeats, when both appear (the
+ * last is the decimal), or when it has three digits after its only one and
+ * the file's mark is the other character. Null when it isn't a number.
+ */
+export declare const parseNumber: (value: string, mark?: DecimalMark) => ParsedNumber | null;
+export declare const normaliseHeader: (header: string) => string;
+export declare const columnNameFromHeader: (header: string, index: number) => string;
+export interface GuessOptions {
+    decimalMark?: DecimalMark;
+    header?: string;
+}
+export declare const guessColumnType: (values: ImportCell[], options?: GuessOptions) => {
+    type: DataColumnType;
+    values?: string[];
+};
+export declare const guessColumns: (headers: string[], rows: ImportRow[], options?: {
+    decimalMark?: DecimalMark;
+}) => DataColumnInput[];
+export declare const matchHeaders: (headers: string[], table: Pick<DataTable, "columns">) => (string | null)[];
+export type RelationLookup = Map<string, number>;
+export declare const relationKey: (value: ImportCell) => string;
+export interface NumberGuess {
+    column: string;
+    text: string;
+    read: number;
+    alternative: number;
+}
+export type CellResult = {
+    ok: true;
+    value: unknown;
+    warning?: NumberGuess;
+} | {
+    ok: false;
+    error: string;
+};
+export interface CellOptions {
+    relation?: RelationLookup;
+    timeZone?: string;
+    decimalMark?: DecimalMark;
+}
+export declare const importCell: (table: Pick<DataTable, "name">, column: DataColumn, cell: ImportCell, options?: CellOptions) => CellResult;
+export interface ImportedRow {
+    index: number;
+    line: number;
+    values: Record<string, unknown>;
+    errors: string[];
+    warnings: NumberGuess[];
+}
+export declare const importRows: (table: Pick<DataTable, "name" | "columns">, mapping: (string | null)[], rows: ImportRow[], options?: {
+    relations?: Record<string, RelationLookup>;
+    timeZone?: string;
+    decimalMark?: DecimalMark;
+    lines?: number[];
+}) => ImportedRow[];
+export declare const csvLine: (cells: ImportCell[]) => string;
+export { detectSeparator, parseCsv } from './dataCsv';
+export type { ParsedCsv } from './dataCsv';
+//# sourceMappingURL=dataImport.d.ts.map

package/dist/dataImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataImport.d.ts","sourceRoot":"","sources":["../src/dataImport.ts"],"names":[],"mappings":"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"}

package/dist/dataImport.js

@@ -0,0 +1,453 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCsv = exports.detectSeparator = exports.csvLine = exports.importRows = exports.importCell = exports.relationKey = exports.matchHeaders = exports.guessColumns = exports.guessColumnType = exports.columnNameFromHeader = exports.normaliseHeader = exports.parseNumber = exports.detectDecimalMark = exports.DATA_IMPORT_BATCH = exports.DATA_IMPORT_SAMPLE_ROWS = exports.toTableInput = exports.isValidIdentifier = exports.identifierIssue = void 0;
+// Reading a spreadsheet into a table: the column types guessed for a new
+// table, the headers matched to an existing one's columns, and each cell
+// checked the way the database will check it. The dashboard's import and
+// `ganju data import` both use these, so a file lands the same way from
+// either. Entry point `@ganju/utils/dataImport`.
+const dataCompiler_1 = require("./dataCompiler");
+const dataIdentifiers_1 = require("./dataIdentifiers");
+const dataTypes_1 = require("./dataTypes");
+var dataIdentifiers_2 = require("./dataIdentifiers");
+Object.defineProperty(exports, "identifierIssue", { enumerable: true, get: function () { return dataIdentifiers_2.identifierIssue; } });
+Object.defineProperty(exports, "isValidIdentifier", { enumerable: true, get: function () { return dataIdentifiers_2.isValidIdentifier; } });
+// The CLI reads tables through this entry point too, and writes them back
+// out the way an export's schema.json does.
+var dataTypes_2 = require("./dataTypes");
+Object.defineProperty(exports, "toTableInput", { enumerable: true, get: function () { return dataTypes_2.toTableInput; } });
+// How many rows the type guess reads.
+exports.DATA_IMPORT_SAMPLE_ROWS = 200;
+// Rows sent per request, the API's own limit.
+exports.DATA_IMPORT_BATCH = 500;
+// Up to this many distinct values, each seen at least twice on average, a
+// text column reads as a list of options.
+const ENUM_MAX_DISTINCT = 12;
+const LONG_TEXT_LENGTH = 200;
+const TRUE_WORDS = new Set(['true', 'yes', 'y', 'si', 'sí', 'verdadero', '1']);
+const FALSE_WORDS = new Set(['false', 'no', 'n', 'falso', '0']);
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/;
+const EMAIL = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+const URL = /^https?:\/\/\S+$/i;
+// Digits with the usual separators, long enough not to be a quantity.
+const PHONE = /^\+?[\d\s().-]{7,25}$/;
+// A header that names a phone column: its numbers are phones even when the
+// sheet stored them as plain numbers.
+const PHONE_HEADER = /phone|tel|telefono|celular|movil|mobile|whatsapp/;
+// Digits with "." or "," between them, nothing else.
+const NUMBER_TEXT = /^-?\d+([.,]\d+)*$/;
+// A code, not a quantity: "05001" loses its zero as a number.
+const LEADING_ZERO = /^-?0\d/;
+const isBlank = (cell) => cell === null || cell === undefined || String(cell).trim() === '';
+const text = (cell) => String(cell ?? '').trim();
+const otherMark = (mark) => (mark === '.' ? ',' : '.');
+// What one value says about the file's decimal mark on its own, or null when
+// it could be either: "28.000" is 28 thousand or 28.
+const markOf = (value) => {
+    if (!NUMBER_TEXT.test(value))
+        return null;
+    const dot = value.lastIndexOf('.');
+    const comma = value.lastIndexOf(',');
+    if (dot >= 0 && comma >= 0)
+        return dot > comma ? '.' : ',';
+    const mark = dot >= 0 ? '.' : ',';
+    const parts = value.replace(/^-/, '').split(mark);
+    if (parts.length === 1)
+        return null;
+    // Used twice, it can only group thousands.
+    if (parts.length > 2)
+        return otherMark(mark);
+    const [whole, fraction] = parts;
+    if (fraction.length !== 3 || whole.length > 3 || /^0+$/.test(whole))
+        return mark;
+    return null;
+};
+/**
+ * The decimal mark a file's numbers use, from the values that can only be
+ * read one way ("12,5", "1.234.567", "1,234.50"). Undefined when none of
+ * them say, or they disagree evenly: each "28.000" is then flagged.
+ */
+const detectDecimalMark = (rows) => {
+    let dot = 0;
+    let comma = 0;
+    for (const row of rows) {
+        for (const cell of row) {
+            if (typeof cell !== 'string')
+                continue;
+            const mark = markOf(cell.trim());
+            if (mark === '.')
+                dot++;
+            else if (mark === ',')
+                comma++;
+        }
+    }
+    if (dot === comma)
+        return undefined;
+    return dot > comma ? '.' : ',';
+};
+exports.detectDecimalMark = detectDecimalMark;
+/**
+ * A number as a sheet writes it, with its thousands separators:
+ * "28.000" → 28000 and "1.234,50" → 1234.5 with a "," mark. A value is
+ * thousands-separated when the same separator repeats, when both appear (the
+ * last is the decimal), or when it has three digits after its only one and
+ * the file's mark is the other character. Null when it isn't a number.
+ */
+const parseNumber = (value, mark) => {
+    const raw = value.trim();
+    if (!NUMBER_TEXT.test(raw))
+        return null;
+    const negative = raw.startsWith('-');
+    const digits = negative ? raw.slice(1) : raw;
+    const dot = digits.lastIndexOf('.');
+    const comma = digits.lastIndexOf(',');
+    let decimal;
+    let ambiguous = false;
+    if (dot < 0 && comma < 0) {
+        decimal = null;
+    }
+    else if (dot >= 0 && comma >= 0) {
+        decimal = dot > comma ? '.' : ',';
+    }
+    else {
+        const sep = dot >= 0 ? '.' : ',';
+        const own = markOf(digits);
+        if (own !== null) {
+            decimal = own === sep ? sep : null;
+        }
+        else if (mark) {
+            decimal = mark === sep ? sep : null;
+        }
+        else {
+            decimal = null;
+            ambiguous = true;
+        }
+    }
+    const [whole, fraction = '', ...rest] = decimal === null ? [digits] : digits.split(decimal);
+    if (rest.length)
+        return null;
+    const groups = whole.split(/[.,]/);
+    // Thousands come in threes after a first group of one to three digits.
+    if (groups.length > 1 &&
+        (groups[0].length > 3 ||
+            groups.slice(1).some(g => g.length !== 3) ||
+            new Set(whole.replace(/\d/g, '')).size > 1)) {
+        return null;
+    }
+    if (fraction && /[.,]/.test(fraction))
+        return null;
+    const n = Number(`${negative ? '-' : ''}${groups.join('')}${fraction ? `.${fraction}` : ''}`);
+    return Number.isFinite(n) ? { value: n, ambiguous } : null;
+};
+exports.parseNumber = parseNumber;
+// Lowercase, no accents, nothing but letters and digits: how a header is
+// compared with a column's name or label.
+const normaliseHeader = (header) => header
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, '');
+exports.normaliseHeader = normaliseHeader;
+// A header as a column name the database accepts: "Precio (COP)" →
+// "precio_cop". A name every table already has gets a prefix, so a sheet's
+// own "id" column is kept as "source_id".
+const columnNameFromHeader = (header, index) => {
+    let name = header
+        .normalize('NFKD')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_{2,}/g, '_')
+        .slice(0, 63);
+    if (!name)
+        name = `column_${index + 1}`;
+    if (!/^[a-z]/.test(name))
+        name = `c_${name}`.slice(0, 63);
+    if (dataIdentifiers_1.DATA_SYSTEM_COLUMNS.includes(name) ||
+        dataIdentifiers_1.DATA_HIDDEN_COLUMNS.includes(name) ||
+        (0, dataIdentifiers_1.identifierIssue)(name, 'column') !== null) {
+        name = `source_${name}`.slice(0, 63);
+    }
+    return (0, dataIdentifiers_1.identifierIssue)(name, 'column') === null ? name : `column_${index + 1}`;
+};
+exports.columnNameFromHeader = columnNameFromHeader;
+// How many values in a sample may disagree with a column's type and still
+// have it guessed: a typo in one cell shouldn't turn a price column into
+// text. Those rows are flagged in the preview instead.
+const tolerated = (count) => count < 3 ? 0 : Math.max(1, Math.floor(count * 0.1));
+// The type the values in one column read as, from the first sample rows.
+const guessColumnType = (values, options = {}) => {
+    const cells = values
+        .slice(0, exports.DATA_IMPORT_SAMPLE_ROWS)
+        .filter(cell => !isBlank(cell));
+    if (cells.length === 0)
+        return { type: 'text' };
+    const count = (test) => cells.filter(test).length;
+    const mostly = (matches) => matches > 0 && cells.length - matches <= tolerated(cells.length);
+    if (mostly(count(cell => typeof cell === 'boolean')))
+        return { type: 'boolean' };
+    if (options.header &&
+        PHONE_HEADER.test((0, exports.normaliseHeader)(options.header)) &&
+        mostly(count(cell => {
+            const value = text(cell);
+            return PHONE.test(value) && value.replace(/\D/g, '').length >= 7;
+        }))) {
+        return { type: 'phone' };
+    }
+    // Codes with a leading zero stay text, so "05001" keeps its zero.
+    if (count(cell => typeof cell === 'string' && LEADING_ZERO.test(cell.trim()))) {
+        return { type: 'text' };
+    }
+    const numberOf = (cell) => typeof cell === 'number'
+        ? cell
+        : (0, exports.parseNumber)(text(cell), options.decimalMark)?.value;
+    const integers = count(cell => {
+        const n = numberOf(cell);
+        return n !== undefined && Number.isSafeInteger(n);
+    });
+    const decimals = count(cell => {
+        const n = numberOf(cell);
+        return n !== undefined && Number.isFinite(n);
+    });
+    // 0/1 alone is still a number column: a quantity of 1 is common. A
+    // column with any fractions is decimal, so none of them is refused.
+    if (decimals > integers && mostly(decimals))
+        return { type: 'decimal' };
+    if (mostly(integers))
+        return { type: 'integer' };
+    if (mostly(count(cell => {
+        const word = text(cell).toLowerCase();
+        return TRUE_WORDS.has(word) || FALSE_WORDS.has(word);
+    }))) {
+        return { type: 'boolean' };
+    }
+    if (mostly(count(cell => DATE.test(text(cell)))))
+        return { type: 'date' };
+    if (mostly(count(cell => DATETIME.test(text(cell)))))
+        return { type: 'datetime' };
+    if (mostly(count(cell => EMAIL.test(text(cell)))))
+        return { type: 'email' };
+    if (mostly(count(cell => URL.test(text(cell)))))
+        return { type: 'url' };
+    if (mostly(count(cell => PHONE.test(text(cell)) && text(cell).replace(/\D/g, '').length >= 7))) {
+        return { type: 'phone' };
+    }
+    if (cells.some(cell => text(cell).length > LONG_TEXT_LENGTH)) {
+        return { type: 'long_text' };
+    }
+    const distinct = new Map();
+    for (const cell of cells) {
+        const value = text(cell);
+        if (value.length > 100) {
+            distinct.clear();
+            break;
+        }
+        const key = value.toLowerCase();
+        if (!distinct.has(key))
+            distinct.set(key, value);
+    }
+    if (distinct.size > 0 &&
+        distinct.size <= ENUM_MAX_DISTINCT &&
+        distinct.size <= dataTypes_1.DATA_MAX_ENUM_VALUES &&
+        cells.length >= distinct.size * 2) {
+        return { type: 'enum', values: [...distinct.values()] };
+    }
+    return { type: 'text' };
+};
+exports.guessColumnType = guessColumnType;
+// The columns of a new table made from a file: one per header, named from
+// it, typed from its values.
+const guessColumns = (headers, rows, options = {}) => {
+    const used = new Set();
+    return headers.slice(0, dataTypes_1.DATA_MAX_COLUMNS).map((header, index) => {
+        let name = (0, exports.columnNameFromHeader)(header, index);
+        for (let n = 2; used.has(name); n++) {
+            name = `${(0, exports.columnNameFromHeader)(header, index).slice(0, 60)}_${n}`;
+        }
+        used.add(name);
+        const guess = (0, exports.guessColumnType)(rows.map(row => row[index]), { decimalMark: options.decimalMark, header });
+        const label = header.trim();
+        return {
+            name,
+            type: guess.type,
+            ...(label && label !== name ? { label: label.slice(0, 100) } : {}),
+            ...(guess.values ? { values: guess.values } : {})
+        };
+    });
+};
+exports.guessColumns = guessColumns;
+// Which column each header fills: matched by name or label, ignoring case,
+// accents and punctuation. `null` for a header that matches nothing; the
+// owner maps those by hand.
+const matchHeaders = (headers, table) => {
+    const taken = new Set();
+    return headers.map(header => {
+        const key = (0, exports.normaliseHeader)(header);
+        if (!key)
+            return null;
+        const column = table.columns.find(c => !taken.has(c.name) &&
+            ((0, exports.normaliseHeader)(c.name) === key ||
+                (c.label !== null && (0, exports.normaliseHeader)(c.label) === key)));
+        if (!column)
+            return null;
+        taken.add(column.name);
+        return column.name;
+    });
+};
+exports.matchHeaders = matchHeaders;
+const relationKey = (value) => text(value)
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase();
+exports.relationKey = relationKey;
+// One cell as the column will store it, or why it won't fit. The check is
+// the database's own, so a row that passes here is refused only for what
+// needs the stored rows (a duplicate in a unique column).
+const importCell = (table, column, cell, options = {}) => {
+    if (isBlank(cell)) {
+        return column.required
+            ? { ok: false, error: `${column.name} is required.` }
+            : { ok: true, value: null };
+    }
+    let value = typeof cell === 'string' ? cell.trim() : cell;
+    let warning;
+    if ((column.type === 'integer' || column.type === 'decimal') &&
+        typeof value === 'string') {
+        const parsed = (0, exports.parseNumber)(value, options.decimalMark);
+        if (parsed) {
+            if (parsed.ambiguous) {
+                warning = {
+                    column: column.name,
+                    text: value,
+                    read: parsed.value,
+                    alternative: Number(value.replace(',', '.'))
+                };
+            }
+            value = parsed.value;
+        }
+    }
+    else if (column.type === 'relation') {
+        const asId = typeof value === 'number' ? value : Number(text(cell));
+        const found = options.relation?.get((0, exports.relationKey)(cell));
+        if (found !== undefined)
+            value = found;
+        else if (Number.isSafeInteger(asId) && asId > 0)
+            value = asId;
+        else {
+            return {
+                ok: false,
+                error: `${column.name}: "${text(cell)}" matches no row in ${column.table}.`
+            };
+        }
+    }
+    else if (column.type === 'boolean' && typeof value === 'string') {
+        const word = value.toLowerCase();
+        if (TRUE_WORDS.has(word))
+            value = true;
+        else if (FALSE_WORDS.has(word))
+            value = false;
+    }
+    else if (column.type === 'json' && typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return { ok: false, error: `${column.name} is not valid JSON.` };
+        }
+    }
+    else if (column.type === 'date' && typeof value === 'string') {
+        // A spreadsheet's date with a midnight time.
+        value = value.replace(/[T ]00:00(:00(\.0+)?)?Z?$/, '');
+    }
+    try {
+        const stored = (0, dataCompiler_1.toStored)(table, column, value, options.timeZone);
+        // The database refuses these too, but only once a whole batch is sent.
+        if (column.min !== null &&
+            column.min !== undefined &&
+            typeof stored === 'number' &&
+            stored < column.min) {
+            return {
+                ok: false,
+                error: `${table.name}.${column.name} can't go below ${column.min}.`
+            };
+        }
+        if (column.type === 'boolean')
+            return { ok: true, value: stored === 1 };
+        if (column.type === 'json')
+            return { ok: true, value };
+        return warning
+            ? { ok: true, value: stored, warning }
+            : { ok: true, value: stored };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+};
+exports.importCell = importCell;
+// Every row of the file as the values it will insert, with each problem
+// found. `mapping[i]` is the column header i fills, or null to skip it.
+// `lines[i]` is row i's line in the file, when blank rows were left out
+// before; otherwise rows follow the header one per line.
+const importRows = (table, mapping, rows, options = {}) => {
+    const columns = new Map(table.columns.map(c => [c.name, c]));
+    const mapped = new Set(mapping.filter((m) => m !== null));
+    const missing = table.columns.filter(c => c.required && c.default === undefined && !mapped.has(c.name));
+    // A unique column's values seen so far, with the line they came from: the
+    // database refuses a file that repeats one, and can't say which row did.
+    const seen = new Map();
+    return rows.map((row, index) => {
+        const line = options.lines?.[index] ?? index + 2;
+        const values = {};
+        const errors = missing.map(c => `${c.name} is required.`);
+        const warnings = [];
+        mapping.forEach((name, i) => {
+            if (name === null)
+                return;
+            const column = columns.get(name);
+            if (!column)
+                return;
+            const result = (0, exports.importCell)(table, column, row[i], {
+                relation: options.relations?.[name],
+                timeZone: options.timeZone,
+                decimalMark: options.decimalMark
+            });
+            if (!result.ok) {
+                errors.push(result.error);
+                return;
+            }
+            if (result.value !== null)
+                values[name] = result.value;
+            if (result.warning)
+                warnings.push(result.warning);
+            if (column.unique && result.value !== null) {
+                const key = JSON.stringify(result.value);
+                const lines = seen.get(name) ?? new Map();
+                seen.set(name, lines);
+                const first = lines.get(key);
+                if (first === undefined)
+                    lines.set(key, line);
+                else {
+                    errors.push(`${column.name}: "${text(row[i])}" is already on line ${first}, and this column takes each value once.`);
+                }
+            }
+        });
+        return { index, line, values, errors, warnings };
+    });
+};
+exports.importRows = importRows;
+// A CSV line, quoted where it needs to be: for the file of refused rows.
+const csvLine = (cells) => cells
+    .map(cell => {
+    const value = cell === null || cell === undefined ? '' : String(cell);
+    return /[",\n\r]/.test(value) ? `"${value.replace(/"/g, '""')}"` : value;
+})
+    .join(',');
+exports.csvLine = csvLine;
+var dataCsv_1 = require("./dataCsv");
+Object.defineProperty(exports, "detectSeparator", { enumerable: true, get: function () { return dataCsv_1.detectSeparator; } });
+Object.defineProperty(exports, "parseCsv", { enumerable: true, get: function () { return dataCsv_1.parseCsv; } });