@ganju/utils 0.0.14 → 0.0.16

package/dist/dataDdl.d.ts

@@ -0,0 +1,29 @@
+import type { DataColumn, DataColumnType, DataDefaultValue, DataTable } from './dataTypes';
+export declare const DATA_NOW_SQL = "strftime('%Y-%m-%dT%H:%M:%SZ', 'now')";
+export declare const TEXT_LIKE_TYPES: ReadonlySet<DataColumnType>;
+export declare const NUMERIC_TYPES: ReadonlySet<DataColumnType>;
+export declare const SEARCHABLE_TYPES: ReadonlySet<DataColumnType>;
+export declare const UNIQUE_TYPES: ReadonlySet<DataColumnType>;
+export declare const sqlLiteral: (value: DataDefaultValue) => string;
+export declare const indexName: (table: Pick<DataTable, "id">, column: DataColumn) => string;
+export declare const uniqueIndexName: (table: Pick<DataTable, "id">, column: DataColumn) => string;
+export declare const participantIndexName: (table: Pick<DataTable, "id">) => string;
+export declare const ftsTableName: (table: Pick<DataTable, "name">) => string;
+export declare const triggerPrefix: (table: Pick<DataTable, "id">) => string;
+export declare const checkConstraintName: (column: Pick<DataColumn, "id">) => string;
+export declare const minConstraintName: (column: Pick<DataColumn, "id">) => string;
+export declare const storedDefault: (column: Pick<DataColumn, "type">, value: DataDefaultValue) => DataDefaultValue;
+export declare const columnDefinitionSql: (column: DataColumn) => string;
+export declare const createTableSql: (name: string, columns: readonly DataColumn[]) => string;
+export interface NamedStatement {
+    name: string;
+    sql: string;
+}
+export declare const desiredIndexes: (table: DataTable) => NamedStatement[];
+export declare const isIndexedColumn: (column: DataColumn) => boolean;
+export declare const searchableColumns: (table: DataTable) => DataColumn[];
+export declare const ftsCreateSql: (table: DataTable) => string | null;
+export declare const desiredTriggers: (table: DataTable) => NamedStatement[];
+export declare const conversionSql: (fromType: DataColumnType, to: DataColumn, src: string) => string;
+export declare const invalidAfterConversionSql: (to: DataColumn, src: string, converted: string) => string;
+//# sourceMappingURL=dataDdl.d.ts.map

package/dist/dataDdl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataDdl.d.ts","sourceRoot":"","sources":["../src/dataDdl.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,SAAS,EACV,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,YAAY,0CAA0C,CAAC;AAEpE,eAAO,MAAM,eAAe,EAAE,WAAW,CAAC,cAAc,CAOtD,CAAC;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,cAAc,CAGpD,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,cAAc,CAOvD,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,WAAW,CAAC,cAAc,CAWnD,CAAC;AAIH,eAAO,MAAM,UAAU,GAAI,OAAO,gBAAgB,KAAG,MAQpD,CAAC;AAIF,eAAO,MAAM,SAAS,GAAI,OAAO,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,QAAQ,UAAU,WAC3C,CAAC;AAChC,eAAO,MAAM,eAAe,GAC1B,OAAO,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,EAC5B,QAAQ,UAAU,WACc,CAAC;AACnC,eAAO,MAAM,oBAAoB,GAAI,OAAO,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WACnC,CAAC;AAC/B,eAAO,MAAM,YAAY,GAAI,OAAO,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,WACrC,CAAC;AACvB,eAAO,MAAM,aAAa,GAAI,OAAO,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,WACvC,CAAC;AACpB,eAAO,MAAM,mBAAmB,GAAI,QAAQ,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,WAC9C,CAAC;AACrB,eAAO,MAAM,iBAAiB,GAAI,QAAQ,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,WAC5C,CAAC;AAGrB,eAAO,MAAM,aAAa,GACxB,QAAQ,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,EAChC,OAAO,gBAAgB,KACtB,gBAKF,CAAC;AA2CF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,UAAU,KAAG,MAuBxD,CAAC;AAKF,eAAO,MAAM,cAAc,GACzB,MAAM,MAAM,EACZ,SAAS,SAAS,UAAU,EAAE,KAC7B,MAcW,CAAC;AAEf,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAMD,eAAO,MAAM,cAAc,GAAI,OAAO,SAAS,KAAG,cAAc,EA6B/D,CAAC;AAGF,eAAO,MAAM,eAAe,GAAI,QAAQ,UAAU,KAAG,OAI7B,CAAC;AAEzB,eAAO,MAAM,iBAAiB,GAAI,OAAO,SAAS,KAAG,UAAU,EAG5D,CAAC;AAKJ,eAAO,MAAM,YAAY,GAAI,OAAO,SAAS,KAAG,MAAM,GAAG,IAQxD,CAAC;AAkGF,eAAO,MAAM,eAAe,GAAI,OAAO,SAAS,KAAG,cAAc,EAGhE,CAAC;AAOF,eAAO,MAAM,aAAa,GACxB,UAAU,cAAc,EACxB,IAAI,UAAU,EACd,KAAK,MAAM,KACV,MAgCF,CAAC;AAIF,eAAO,MAAM,yBAAyB,GACpC,IAAI,UAAU,EACd,KAAK,MAAM,EACX,WAAW,MAAM,KAChB,MAyBF,CAAC"}

package/dist/dataDdl.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidAfterConversionSql = exports.conversionSql = exports.desiredTriggers = exports.ftsCreateSql = exports.searchableColumns = exports.isIndexedColumn = exports.desiredIndexes = exports.createTableSql = exports.columnDefinitionSql = exports.storedDefault = exports.minConstraintName = exports.checkConstraintName = exports.triggerPrefix = exports.ftsTableName = exports.participantIndexName = exports.uniqueIndexName = exports.indexName = exports.sqlLiteral = exports.UNIQUE_TYPES = exports.SEARCHABLE_TYPES = exports.NUMERIC_TYPES = exports.TEXT_LIKE_TYPES = exports.DATA_NOW_SQL = void 0;
+// The SQL a project's database runs to build and change its tables. Pure
+// string building: every name in here passed identifierIssue or is one of
+// ours, and every owner-supplied value is a literal escaped by sqlLiteral.
+const dataIdentifiers_1 = require("./dataIdentifiers");
+exports.DATA_NOW_SQL = "strftime('%Y-%m-%dT%H:%M:%SZ', 'now')";
+exports.TEXT_LIKE_TYPES = new Set([
+    'text',
+    'long_text',
+    'email',
+    'url',
+    'phone',
+    'file'
+]);
+exports.NUMERIC_TYPES = new Set([
+    'integer',
+    'decimal'
+]);
+// Columns full-text search can cover.
+exports.SEARCHABLE_TYPES = new Set([
+    'text',
+    'long_text',
+    'email',
+    'url',
+    'phone',
+    'enum'
+]);
+// Columns a unique index makes sense on.
+exports.UNIQUE_TYPES = new Set([
+    'text',
+    'email',
+    'url',
+    'phone',
+    'integer',
+    'decimal',
+    'date',
+    'datetime',
+    'enum',
+    'relation'
+]);
+// Literal for a value the owner typed (a default, an enum value). Strings are
+// single-quoted with quotes doubled; nothing else reaches SQL unescaped.
+const sqlLiteral = (value) => {
+    if (value === null)
+        return 'NULL';
+    if (typeof value === 'boolean')
+        return value ? '1' : '0';
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error('not a finite number');
+        return String(value);
+    }
+    return `'${String(value).replace(/'/g, "''")}'`;
+};
+exports.sqlLiteral = sqlLiteral;
+// Names derived from stable ids, so renaming a table or column never leaves
+// an index or constraint behind under the old name.
+const indexName = (table, column) => `ix_${table.id}_${column.id}`;
+exports.indexName = indexName;
+const uniqueIndexName = (table, column) => `ux_${table.id}_${column.id}`;
+exports.uniqueIndexName = uniqueIndexName;
+const participantIndexName = (table) => `ix_${table.id}_participant`;
+exports.participantIndexName = participantIndexName;
+const ftsTableName = (table) => `${table.name}__fts`;
+exports.ftsTableName = ftsTableName;
+const triggerPrefix = (table) => `tr_${table.id}_`;
+exports.triggerPrefix = triggerPrefix;
+const checkConstraintName = (column) => `chk_${column.id}`;
+exports.checkConstraintName = checkConstraintName;
+const minConstraintName = (column) => `min_${column.id}`;
+exports.minConstraintName = minConstraintName;
+// The default as SQLite stores it: booleans as 0/1, JSON as its text.
+const storedDefault = (column, value) => {
+    if (value === null)
+        return null;
+    if (column.type === 'boolean')
+        return value ? 1 : 0;
+    if (column.type === 'json')
+        return JSON.stringify(value);
+    return value;
+};
+exports.storedDefault = storedDefault;
+const typeCheck = (column) => {
+    const c = (0, dataIdentifiers_1.quoteIdentifier)(column.name);
+    switch (column.type) {
+        case 'integer':
+        case 'relation':
+            return { affinity: 'INTEGER', check: `typeof(${c}) = 'integer'` };
+        case 'decimal':
+            return {
+                affinity: 'REAL',
+                check: `typeof(${c}) IN ('real', 'integer')`
+            };
+        case 'boolean':
+            return { affinity: 'INTEGER', check: `${c} IN (0, 1)` };
+        case 'date':
+            return {
+                affinity: 'TEXT',
+                check: `typeof(${c}) = 'text' AND date(${c}) = ${c}`
+            };
+        case 'datetime':
+            return {
+                affinity: 'TEXT',
+                check: `typeof(${c}) = 'text' AND strftime('%Y-%m-%dT%H:%M:%SZ', ${c}) = ${c}`
+            };
+        case 'enum':
+            return {
+                affinity: 'TEXT',
+                check: `${c} IN (${(column.values ?? []).map(exports.sqlLiteral).join(', ')})`
+            };
+        case 'json':
+            return { affinity: 'TEXT', check: `json_valid(${c})` };
+        default:
+            return { affinity: 'TEXT', check: `typeof(${c}) = 'text'` };
+    }
+};
+const ON_DELETE_SQL = {
+    restrict: 'RESTRICT',
+    cascade: 'CASCADE',
+    set_null: 'SET NULL'
+};
+const columnDefinitionSql = (column) => {
+    const c = (0, dataIdentifiers_1.quoteIdentifier)(column.name);
+    const { affinity, check } = typeCheck(column);
+    const parts = [
+        c,
+        affinity,
+        `CONSTRAINT ${(0, dataIdentifiers_1.quoteIdentifier)((0, exports.checkConstraintName)(column))} CHECK (${c} IS NULL OR (${check}))`
+    ];
+    if (column.min !== null && exports.NUMERIC_TYPES.has(column.type)) {
+        parts.push(`CONSTRAINT ${(0, dataIdentifiers_1.quoteIdentifier)((0, exports.minConstraintName)(column))} CHECK (${c} IS NULL OR ${c} >= ${(0, exports.sqlLiteral)(column.min)})`);
+    }
+    if (column.type === 'relation' && column.table) {
+        parts.push(`REFERENCES ${(0, dataIdentifiers_1.quoteIdentifier)(column.table)}(id) ON DELETE ${ON_DELETE_SQL[column.onDelete ?? 'restrict']}`);
+    }
+    if (column.required)
+        parts.push('NOT NULL');
+    if (column.default !== undefined && column.default !== null) {
+        parts.push(`DEFAULT ${(0, exports.sqlLiteral)((0, exports.storedDefault)(column, column.default))}`);
+    }
+    return parts.join(' ');
+};
+exports.columnDefinitionSql = columnDefinitionSql;
+// Every table has the same system columns around the owner's. The hidden
+// participant_id is always there, so turning customer scoping on is an index,
+// not a table change.
+const createTableSql = (name, columns) => [
+    `CREATE TABLE ${(0, dataIdentifiers_1.quoteIdentifier)(name)} (`,
+    [
+        'id INTEGER PRIMARY KEY',
+        ...columns.map(exports.columnDefinitionSql),
+        `created_at TEXT NOT NULL DEFAULT (${exports.DATA_NOW_SQL})`,
+        `updated_at TEXT NOT NULL DEFAULT (${exports.DATA_NOW_SQL})`,
+        'version INTEGER NOT NULL DEFAULT 1',
+        'created_by TEXT',
+        'updated_by TEXT',
+        'participant_id TEXT'
+    ].join(',\n  '),
+    ')'
+].join('\n');
+exports.createTableSql = createTableSql;
+// The indexes a table should have: every relation and file column (SQLite
+// doesn't index the child side of a foreign key), every unique column (as a
+// unique index, so the column can still be dropped with ALTER TABLE) and
+// every filterable one.
+const desiredIndexes = (table) => {
+    const out = [];
+    for (const column of table.columns) {
+        if (column.unique) {
+            const name = (0, exports.uniqueIndexName)(table, column);
+            out.push({
+                name,
+                sql: `CREATE UNIQUE INDEX ${(0, dataIdentifiers_1.quoteIdentifier)(name)} ON ${(0, dataIdentifiers_1.quoteIdentifier)(table.name)}(${(0, dataIdentifiers_1.quoteIdentifier)(column.name)})`
+            });
+        }
+        else if (column.type === 'relation' ||
+            column.type === 'file' ||
+            column.filterable) {
+            const name = (0, exports.indexName)(table, column);
+            out.push({
+                name,
+                sql: `CREATE INDEX ${(0, dataIdentifiers_1.quoteIdentifier)(name)} ON ${(0, dataIdentifiers_1.quoteIdentifier)(table.name)}(${(0, dataIdentifiers_1.quoteIdentifier)(column.name)})`
+            });
+        }
+    }
+    if (table.customerScoped) {
+        const name = (0, exports.participantIndexName)(table);
+        out.push({
+            name,
+            sql: `CREATE INDEX ${(0, dataIdentifiers_1.quoteIdentifier)(name)} ON ${(0, dataIdentifiers_1.quoteIdentifier)(table.name)}(participant_id)`
+        });
+    }
+    return out;
+};
+exports.desiredIndexes = desiredIndexes;
+// Whether a filter or sort on this column is served by an index.
+const isIndexedColumn = (column) => column.unique ||
+    column.filterable ||
+    column.type === 'relation' ||
+    column.type === 'file';
+exports.isIndexedColumn = isIndexedColumn;
+const searchableColumns = (table) => table.columns.filter(column => column.searchable && exports.SEARCHABLE_TYPES.has(column.type));
+exports.searchableColumns = searchableColumns;
+// The search table: an external-content FTS5 table over the searchable
+// columns, accent-insensitive ("jalapeno" finds "jalapeño"). Null when the
+// table has nothing searchable.
+const ftsCreateSql = (table) => {
+    const columns = (0, exports.searchableColumns)(table);
+    if (columns.length === 0)
+        return null;
+    return `CREATE VIRTUAL TABLE ${(0, dataIdentifiers_1.quoteIdentifier)((0, exports.ftsTableName)(table))} USING fts5(${columns
+        .map(c => (0, dataIdentifiers_1.quoteIdentifier)(c.name))
+        .join(', ')}, content=${(0, exports.sqlLiteral)(table.name)}, content_rowid='id', tokenize='unicode61 remove_diacritics 2')`;
+};
+exports.ftsCreateSql = ftsCreateSql;
+const ftsTriggers = (table) => {
+    const columns = (0, exports.searchableColumns)(table);
+    if (columns.length === 0)
+        return [];
+    const fts = (0, dataIdentifiers_1.quoteIdentifier)((0, exports.ftsTableName)(table));
+    const t = (0, dataIdentifiers_1.quoteIdentifier)(table.name);
+    const list = columns.map(c => (0, dataIdentifiers_1.quoteIdentifier)(c.name)).join(', ');
+    const newValues = columns.map(c => `new.${(0, dataIdentifiers_1.quoteIdentifier)(c.name)}`).join(', ');
+    const oldValues = columns.map(c => `old.${(0, dataIdentifiers_1.quoteIdentifier)(c.name)}`).join(', ');
+    const prefix = (0, exports.triggerPrefix)(table);
+    return [
+        {
+            name: `${prefix}fts_ai`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}fts_ai`)} AFTER INSERT ON ${t} BEGIN INSERT INTO ${fts}(rowid, ${list}) VALUES (new.id, ${newValues}); END`
+        },
+        {
+            name: `${prefix}fts_ad`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}fts_ad`)} AFTER DELETE ON ${t} BEGIN INSERT INTO ${fts}(${fts}, rowid, ${list}) VALUES ('delete', old.id, ${oldValues}); END`
+        },
+        {
+            // Only when a searchable column changes, so a stock decrement doesn't
+            // rewrite the search index.
+            name: `${prefix}fts_au`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}fts_au`)} AFTER UPDATE OF ${list} ON ${t} BEGIN INSERT INTO ${fts}(${fts}, rowid, ${list}) VALUES ('delete', old.id, ${oldValues}); INSERT INTO ${fts}(rowid, ${list}) VALUES (new.id, ${newValues}); END`
+        }
+    ];
+};
+// json_object takes at most 127 arguments, so wide tables are built in
+// pieces and merged. json_patch drops keys whose value is null, which is what
+// leaves only the changed columns.
+const changedColumnsJson = (columns, value) => {
+    let out = "'{}'";
+    for (let i = 0; i < columns.length; i += 50) {
+        const pairs = columns
+            .slice(i, i + 50)
+            .map(c => `${(0, exports.sqlLiteral)(c.name)}, ${value((0, dataIdentifiers_1.quoteIdentifier)(c.name))}`)
+            .join(', ');
+        out = `json_patch(${out}, json_object(${pairs}))`;
+    }
+    return out;
+};
+// Row history: who changed which columns, old → new. Triggers rather than
+// code, so cascades and SET NULL are recorded too. The actor comes from
+// _ganju_context, which every write sets first.
+const historyTriggers = (table) => {
+    if (!table.history)
+        return [];
+    const t = (0, dataIdentifiers_1.quoteIdentifier)(table.name);
+    const prefix = (0, exports.triggerPrefix)(table);
+    const columns = table.columns;
+    const log = (op, rowId, changes) => `INSERT INTO _ganju_row_log (table_id, row_id, op, actor, at, changes) VALUES (${table.id}, ${rowId}, '${op}', (SELECT actor FROM _ganju_context WHERE id = 1), ${exports.DATA_NOW_SQL}, ${changes})`;
+    const changed = columns.length
+        ? columns.map(c => `old.${(0, dataIdentifiers_1.quoteIdentifier)(c.name)} IS NOT new.${(0, dataIdentifiers_1.quoteIdentifier)(c.name)}`).join(' OR ')
+        : '0';
+    return [
+        {
+            name: `${prefix}log_ai`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}log_ai`)} AFTER INSERT ON ${t} BEGIN ${log('insert', 'new.id', changedColumnsJson(columns, c => `CASE WHEN new.${c} IS NOT NULL THEN json_array(NULL, new.${c}) END`))}; END`
+        },
+        {
+            name: `${prefix}log_au`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}log_au`)} AFTER UPDATE ON ${t} WHEN ${changed} BEGIN ${log('update', 'new.id', changedColumnsJson(columns, c => `CASE WHEN old.${c} IS NOT new.${c} THEN json_array(old.${c}, new.${c}) END`))}; END`
+        },
+        {
+            name: `${prefix}log_ad`,
+            sql: `CREATE TRIGGER ${(0, dataIdentifiers_1.quoteIdentifier)(`${prefix}log_ad`)} AFTER DELETE ON ${t} BEGIN ${log('delete', 'old.id', changedColumnsJson(columns, c => `CASE WHEN old.${c} IS NOT NULL THEN json_array(old.${c}, NULL) END`))}; END`
+        }
+    ];
+};
+const desiredTriggers = (table) => [
+    ...ftsTriggers(table),
+    ...historyTriggers(table)
+];
+exports.desiredTriggers = desiredTriggers;
+// Type changes
+// SQL that turns `src` (the old column's value) into what `to` stores, or
+// NULL when it can't. The rows where it yields NULL from a non-null value
+// are the ones a type change lists and refuses on.
+const conversionSql = (fromType, to, src) => {
+    if (fromType === to.type)
+        return src;
+    switch (to.type) {
+        case 'text':
+        case 'long_text':
+        case 'email':
+        case 'url':
+        case 'phone':
+        case 'file':
+            return fromType === 'boolean'
+                ? `CASE ${src} WHEN 1 THEN 'true' WHEN 0 THEN 'false' END`
+                : `CAST(${src} AS TEXT)`;
+        case 'integer':
+        case 'relation':
+            return `CASE WHEN typeof(${src}) = 'integer' THEN ${src} WHEN typeof(${src}) = 'real' AND ${src} = CAST(${src} AS INTEGER) THEN CAST(${src} AS INTEGER) WHEN typeof(${src}) = 'text' AND trim(${src}) <> '' AND CAST(CAST(trim(${src}) AS INTEGER) AS TEXT) = ltrim(trim(${src}), '+') THEN CAST(trim(${src}) AS INTEGER) END`;
+        case 'decimal':
+            return `CASE WHEN typeof(${src}) IN ('integer', 'real') THEN ${src} WHEN typeof(${src}) = 'text' AND trim(${src}) <> '' AND trim(${src}) NOT GLOB '*[^0-9.eE+-]*' AND trim(${src}) GLOB '*[0-9]*' THEN CAST(trim(${src}) AS REAL) END`;
+        case 'boolean':
+            return `CASE WHEN typeof(${src}) IN ('integer', 'real') AND ${src} IN (0, 1) THEN CAST(${src} AS INTEGER) WHEN typeof(${src}) = 'text' AND lower(trim(${src})) IN ('true', '1', 'yes', 'si', 'sí') THEN 1 WHEN typeof(${src}) = 'text' AND lower(trim(${src})) IN ('false', '0', 'no') THEN 0 END`;
+        case 'date':
+            return `CASE WHEN typeof(${src}) = 'text' THEN date(${src}) END`;
+        case 'datetime':
+            return `CASE WHEN typeof(${src}) = 'text' THEN strftime('%Y-%m-%dT%H:%M:%SZ', ${src}) END`;
+        case 'enum':
+            return `CASE lower(trim(CAST(${src} AS TEXT))) ${(to.values ?? [])
+                .map(v => `WHEN ${(0, exports.sqlLiteral)(v.toLowerCase())} THEN ${(0, exports.sqlLiteral)(v)}`)
+                .join(' ')} END`;
+        case 'json':
+            return fromType === 'boolean'
+                ? `CASE ${src} WHEN 1 THEN 'true' WHEN 0 THEN 'false' END`
+                : `CASE WHEN typeof(${src}) = 'text' AND json_valid(${src}) THEN ${src} ELSE json_quote(${src}) END`;
+    }
+};
+exports.conversionSql = conversionSql;
+// The condition that marks a row whose value can't be kept after the change:
+// it doesn't convert, or breaks one of the new column's rules.
+const invalidAfterConversionSql = (to, src, converted) => {
+    const parts = [`(${src} IS NOT NULL AND (${converted}) IS NULL)`];
+    if (to.required)
+        parts.push(`(${converted}) IS NULL`);
+    if (to.min !== null && exports.NUMERIC_TYPES.has(to.type)) {
+        parts.push(`(${converted}) < ${(0, exports.sqlLiteral)(to.min)}`);
+    }
+    if (to.type === 'enum') {
+        parts.push(`((${converted}) IS NOT NULL AND (${converted}) NOT IN (${(to.values ?? []).map(exports.sqlLiteral).join(', ')}))`);
+    }
+    if (to.type === 'email') {
+        parts.push(`(${converted}) NOT LIKE '%_@_%._%'`);
+    }
+    if (to.type === 'url') {
+        parts.push(`NOT ((${converted}) LIKE 'http://%' OR (${converted}) LIKE 'https://%')`);
+    }
+    if (to.type === 'relation' && to.table) {
+        parts.push(`((${converted}) IS NOT NULL AND NOT EXISTS (SELECT 1 FROM ${(0, dataIdentifiers_1.quoteIdentifier)(to.table)} WHERE id = (${converted})))`);
+    }
+    return parts.join(' OR ');
+};
+exports.invalidAfterConversionSql = invalidAfterConversionSql;

package/dist/dataEngine.d.ts

@@ -0,0 +1,143 @@
+import type { SqlValue } from './dataCompiler';
+import { toTableInput, DataError } from './dataTypes';
+import type { DataCaller, DataColumn, DataDefaultValue, DataDeleteImpact, DataSchema, DataTable, DataTableCopy } from './dataTypes';
+export type SqlRow = Record<string, SqlValue>;
+export interface SqlRunner {
+    all(sql: string, params?: readonly SqlValue[]): SqlRow[];
+    iterate(sql: string, params?: readonly SqlValue[]): Iterable<SqlRow>;
+    transaction<T>(fn: () => T): T;
+    databaseSize(): number;
+}
+export declare const INTERNAL_MIGRATIONS: readonly (readonly string[])[];
+export declare const INTERNAL_SCHEMA_VERSION: number;
+export declare const hasInternalTables: (runner: SqlRunner) => boolean;
+export declare const getMeta: (runner: SqlRunner, key: string) => string | null;
+export declare const setMeta: (runner: SqlRunner, key: string, value: string | null) => void;
+export declare const migrateInternal: (runner: SqlRunner) => number;
+export declare const loadSchema: (runner: SqlRunner) => DataSchema;
+export { toTableInput };
+type ColumnDraft = Omit<DataColumn, 'id' | 'position'>;
+export declare const normaliseColumn: (input: unknown, schema: DataSchema, selfTable: string) => ColumnDraft;
+export declare const translateSqliteError: (schema: DataSchema, table: DataTable, error: unknown) => DataError;
+type ShapedRow = Record<string, unknown> & {
+    id: number;
+};
+export declare const describe: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, rawArgs?: unknown) => {
+    tables: ({
+        displayColumn: string;
+        searchable: string[];
+        columns: ({
+            description?: string | undefined;
+            min?: number | undefined;
+            default?: DataDefaultValue | undefined;
+            references?: string | null | undefined;
+            values?: string[] | undefined;
+            unique?: boolean | undefined;
+            required?: boolean | undefined;
+            label?: string | undefined;
+            name: string;
+            type: "boolean" | "email" | "json" | "text" | "long_text" | "integer" | "decimal" | "date" | "datetime" | "enum" | "url" | "phone" | "relation" | "file";
+        } | {
+            name: string;
+            type: string;
+        })[];
+        referencedBy: string[];
+        rowsAbout: number;
+        onlyThisCustomersRows?: boolean | undefined;
+        description: string | null;
+        access: "none" | "read" | "add" | "full";
+        label?: string | undefined;
+        name: string;
+    } | {
+        displayColumn: string;
+        searchable: string[];
+        columns: ({
+            description?: string | undefined;
+            min?: number | undefined;
+            default?: DataDefaultValue | undefined;
+            references?: string | null | undefined;
+            values?: string[] | undefined;
+            unique?: boolean | undefined;
+            required?: boolean | undefined;
+            label?: string | undefined;
+            name: string;
+            type: "boolean" | "email" | "json" | "text" | "long_text" | "integer" | "decimal" | "date" | "datetime" | "enum" | "url" | "phone" | "relation" | "file";
+        } | {
+            name: string;
+            type: string;
+        })[];
+        referencedBy: string[];
+        rows: number;
+        onlyThisCustomersRows?: boolean | undefined;
+        description: string | null;
+        access: "none" | "read" | "add" | "full";
+        label?: string | undefined;
+        name: string;
+    })[];
+};
+export declare const query: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, rawArgs: unknown) => {
+    groupsTruncated?: string | undefined;
+    scope?: string | undefined;
+    table: string;
+} | {
+    nextCursor?: string | undefined;
+    includeTruncated?: string | undefined;
+    rows: ShapedRow[];
+    searchMatched?: "all words" | "any word" | undefined;
+    total?: number | undefined;
+    scope?: string | undefined;
+    table: string;
+};
+export declare const assertActor: (caller: DataCaller) => void;
+export declare const assertWritable: (runner: SqlRunner, caller: DataCaller, addsData: boolean) => void;
+type WriteResult = {
+    op: 'insert';
+    table: string;
+    id: number;
+} | {
+    op: 'insert';
+    table: string;
+    ids: number[];
+} | {
+    op: 'update' | 'delete';
+    table: string;
+    changed: number;
+};
+export declare const write: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, rawArgs: unknown) => {
+    ok: true;
+    results: WriteResult[];
+};
+export declare const deleteImpact: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, rawArgs: unknown) => DataDeleteImpact;
+export declare const rowHistory: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, args: {
+    table: string;
+    id: number;
+    limit?: number;
+    cursor?: number;
+}) => {
+    nextCursor?: number | undefined;
+    table: string;
+    id: number;
+    entries: {
+        op: SqlValue;
+        actor: SqlValue;
+        at: string;
+        changes: Record<string, [unknown, unknown]>;
+    }[];
+};
+export declare const pruneHistory: (runner: SqlRunner, now?: Date, batch?: number) => number;
+export declare const createTable: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, input: unknown) => DataTable;
+export declare const updateTable: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, name: string, patch: unknown) => DataTable;
+export declare const dropTable: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, name: string) => {
+    dropped: string;
+};
+export declare const addColumn: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, tableName: string, input: unknown) => DataTable;
+export declare const columnChangeNeedsRebuild: (schema: DataSchema, tableName: string, columnName: string, patch: unknown) => boolean;
+export declare const dropColumnNeedsRebuild: (schema: DataSchema, tableName: string, columnName: string) => boolean;
+export declare const readTableCopy: (runner: SqlRunner) => DataTableCopy | null;
+export declare const writeReachesCopy: (schema: DataSchema, copy: Pick<DataTableCopy, "table">, rawArgs: unknown) => boolean;
+export declare const clearFailedTableCopy: (runner: SqlRunner) => void;
+export declare const copyTableStep: (runner: SqlRunner, schema: DataSchema) => "more" | "done" | "failed" | "idle";
+export declare const updateColumn: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, tableName: string, columnName: string, patch: unknown) => DataTable;
+export declare const dropColumn: (runner: SqlRunner, schema: DataSchema, caller: DataCaller, tableName: string, columnName: string) => DataTable;
+export declare const exportRows: (runner: SqlRunner, table: DataTable, afterId: number) => Iterable<SqlRow>;
+//# sourceMappingURL=dataEngine.d.ts.map

package/dist/dataEngine.d.ts.map

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