ormbridge 0.3.0 → 0.5.0

package/dist/parsers/sqlTypes.js

@@ -0,0 +1,742 @@
+import { sourceOf } from './sqlSyntax.js';
+/** Words that may follow the first word of a type name, by that first word. */
+const TYPE_CONTINUATIONS = {
+    double: new Set(['precision']),
+    character: new Set(['varying', 'large', 'object']),
+    char: new Set(['varying', 'large', 'object']),
+    nchar: new Set(['varying', 'large', 'object']),
+    national: new Set([
+        'character',
+        'char',
+        'varchar',
+        'varying',
+        'large',
+        'object',
+    ]),
+    native: new Set(['character']),
+    varying: new Set(['character']),
+    bit: new Set(['varying']),
+    binary: new Set(['varying', 'large', 'object']),
+    long: new Set(['varchar', 'raw', 'varbinary']),
+    unsigned: new Set(['big', 'int', 'integer']),
+    big: new Set(['int', 'integer']),
+    interval: new Set(['year', 'month', 'day', 'hour', 'minute', 'second', 'to']),
+};
+/** Second words that may continue a multi-word type after another continuation word. */
+const CHAINED_CONTINUATIONS = new Set([
+    'varying',
+    'character',
+    'char',
+    'large',
+    'object',
+    'int',
+    'integer',
+    'to',
+    'month',
+    'day',
+    'hour',
+    'minute',
+    'second',
+    'year',
+    'precision',
+    'varchar',
+]);
+/**
+ * Reads a column type. Never fails: a cursor at something that is not a type gives an empty name, which the
+ * mapping reports as an unknown type.
+ */
+export function parseType(cursor, text, dialect) {
+    const startToken = cursor.peek();
+    const startPosition = cursor.position;
+    const consumed = [];
+    const nameWords = [];
+    let userName;
+    let args = [];
+    let enumValues;
+    let setValues;
+    let arrayDepth = 0;
+    let unsigned = false;
+    let hasArgs = false;
+    if (startToken.kind === 'ident') {
+        // A quoted type name, possibly schema-qualified: "public"."post_status".
+        let last = cursor.next();
+        consumed.push(last);
+        while (cursor.isPunct('.')) {
+            cursor.next();
+            const part = cursor.peek();
+            if (part.kind === 'ident' || part.kind === 'word') {
+                last = cursor.next();
+                consumed.push(last);
+            }
+            else {
+                break;
+            }
+        }
+        userName = last.value;
+        nameWords.push(last.value.toLowerCase());
+    }
+    else if (startToken.kind === 'word') {
+        cursor.next();
+        consumed.push(startToken);
+        if (cursor.isPunct('.')) {
+            // schema.type
+            let last = startToken;
+            while (cursor.isPunct('.')) {
+                cursor.next();
+                const part = cursor.peek();
+                if (part.kind === 'ident' || part.kind === 'word') {
+                    last = cursor.next();
+                    consumed.push(last);
+                }
+                else {
+                    break;
+                }
+            }
+            userName = last.value;
+            nameWords.push(last.value.toLowerCase());
+        }
+        else {
+            userName = startToken.value;
+            nameWords.push(startToken.value.toLowerCase());
+        }
+    }
+    else {
+        return {
+            name: '',
+            args: [],
+            arrayDepth: 0,
+            unsigned: false,
+            text: '',
+            userName: '',
+        };
+    }
+    const first = nameWords[0] ?? '';
+    const isBuiltInStart = startToken.kind === 'word' && nameWords.length === 1;
+    for (;;) {
+        const token = cursor.peek();
+        if (token.kind === 'word') {
+            const word = token.value.toLowerCase();
+            if (word === 'unsigned' || word === 'signed' || word === 'zerofill') {
+                if (word === 'unsigned') {
+                    unsigned = true;
+                }
+                consumed.push(cursor.next());
+                continue;
+            }
+            if (word === 'array') {
+                arrayDepth += 1;
+                consumed.push(cursor.next());
+                if (cursor.isPunct('[')) {
+                    while (!cursor.atEnd && !cursor.isPunct(']')) {
+                        consumed.push(cursor.next());
+                    }
+                    if (cursor.isPunct(']')) {
+                        consumed.push(cursor.next());
+                    }
+                }
+                continue;
+            }
+            if ((word === 'with' || word === 'without') &&
+                (cursor.isKeyword('TIME', 1) || cursor.isKeyword('LOCAL', 1))) {
+                consumed.push(cursor.next());
+                if (cursor.isKeyword('LOCAL')) {
+                    consumed.push(cursor.next());
+                }
+                if (cursor.isKeyword('TIME')) {
+                    consumed.push(cursor.next());
+                }
+                if (cursor.isKeyword('ZONE')) {
+                    consumed.push(cursor.next());
+                }
+                continue;
+            }
+            const allowed = isBuiltInStart
+                ? TYPE_CONTINUATIONS[first]
+                : undefined;
+            const chained = nameWords.length > 1 && CHAINED_CONTINUATIONS.has(word);
+            if (isBuiltInStart &&
+                (allowed?.has(word) === true || chained) &&
+                // `varchar CHARACTER SET utf8` is a column option, not a type word.
+                !(word === 'character' && cursor.isKeyword('SET', 1))) {
+                nameWords.push(word);
+                consumed.push(cursor.next());
+                continue;
+            }
+            break;
+        }
+        if (token.kind === 'punct' && token.text === '(' && !hasArgs) {
+            hasArgs = true;
+            const group = cursor.readGroup() ?? [];
+            consumed.push(token);
+            for (const inner of group) {
+                consumed.push(inner);
+            }
+            consumed.push(cursor.tokens[cursor.position - 1] ?? token);
+            args = group
+                .filter((inner) => inner.kind === 'number' ||
+                inner.kind === 'word' ||
+                inner.kind === 'ident')
+                .map((inner) => inner.value);
+            const strings = group
+                .filter((inner) => inner.kind === 'string')
+                .map((inner) => inner.value);
+            if (first === 'enum' && strings.length > 0) {
+                enumValues = strings;
+            }
+            else if (first === 'set' && strings.length > 0) {
+                setValues = strings;
+            }
+            continue;
+        }
+        if (token.kind === 'punct' && token.text === '[') {
+            // PostgreSQL array suffix: [] or [3].
+            consumed.push(cursor.next());
+            while (!cursor.atEnd && !cursor.isPunct(']')) {
+                consumed.push(cursor.next());
+            }
+            if (cursor.isPunct(']')) {
+                consumed.push(cursor.next());
+            }
+            arrayDepth += 1;
+            continue;
+        }
+        break;
+    }
+    if (cursor.position === startPosition) {
+        cursor.next();
+    }
+    return {
+        name: nameWords.join(' '),
+        args,
+        arrayDepth,
+        unsigned,
+        ...(enumValues === undefined ? {} : { enumValues }),
+        ...(setValues === undefined ? {} : { setValues }),
+        text: dialect === 'postgresql'
+            ? sourceOf(text, consumed)
+            : sourceOf(text, consumed).replace(/[[\]`]/g, ''),
+        userName,
+    };
+}
+function toInteger(value) {
+    if (value === undefined || !/^\d{1,9}$/.test(value)) {
+        return undefined;
+    }
+    return Number(value);
+}
+const INT_NAMES = new Set([
+    'int',
+    'integer',
+    'int2',
+    'int4',
+    'smallint',
+    'mediumint',
+    'int3',
+    'tinyint',
+    'int1',
+    'year',
+]);
+const BIG_INT_NAMES = new Set([
+    'bigint',
+    'int8',
+    'big int',
+    'unsigned big int',
+]);
+const SERIAL_NAMES = {
+    serial: 'int',
+    serial4: 'int',
+    serial2: 'int',
+    smallserial: 'int',
+    bigserial: 'bigInt',
+    serial8: 'bigInt',
+};
+const FLOAT_NAMES = new Set([
+    'real',
+    'float',
+    'float4',
+    'float8',
+    'double',
+    'double precision',
+    'binary_float',
+    'binary_double',
+]);
+const DECIMAL_NAMES = new Set([
+    'numeric',
+    'decimal',
+    'dec',
+    'fixed',
+    'number',
+]);
+const STRING_NAMES = new Set([
+    'varchar',
+    'character varying',
+    'varying character',
+    'nvarchar',
+    'national varchar',
+    'national character varying',
+    'national char varying',
+    'nchar varying',
+    'varchar2',
+    'nvarchar2',
+    'bpchar',
+    'name',
+    'native character',
+]);
+const FIXED_CHAR_NAMES = new Set([
+    'char',
+    'character',
+    'nchar',
+    'national char',
+    'national character',
+]);
+const TEXT_NAMES = new Set([
+    'text',
+    'tinytext',
+    'mediumtext',
+    'longtext',
+    'ntext',
+    'clob',
+    'nclob',
+    'long',
+    'long varchar',
+    'citext',
+    'character large object',
+    'char large object',
+    'string',
+]);
+const DATE_TIME_NAMES = new Set([
+    'timestamp',
+    'timestamptz',
+    'datetime',
+    'datetime2',
+    'smalldatetime',
+    'datetimeoffset',
+]);
+const BYTES_NAMES = new Set([
+    'bytea',
+    'blob',
+    'tinyblob',
+    'mediumblob',
+    'longblob',
+    'binary',
+    'varbinary',
+    'binary varying',
+    'image',
+    'raw',
+    'long raw',
+    'long varbinary',
+    'binary large object',
+]);
+const RANGE_NAMES = {
+    int4range: 'int',
+    int8range: 'bigInt',
+    numrange: 'decimal',
+    daterange: 'date',
+    tsrange: 'dateTime',
+    tstzrange: 'dateTime',
+};
+/** SQLite assigns a type affinity from substrings of the declared type. */
+function mapSqliteAffinity(name) {
+    if (name.includes('int')) {
+        return { type: 'int' };
+    }
+    if (name.includes('char') || name.includes('clob') || name.includes('text')) {
+        return { type: 'text' };
+    }
+    if (name.includes('blob')) {
+        return { type: 'bytes' };
+    }
+    if (name.includes('real') || name.includes('floa') || name.includes('doub')) {
+        return { type: 'float' };
+    }
+    return undefined;
+}
+/** Maps a column type to the shared model. Unknown names come back as `isUserType` (possibly an enum). */
+export function mapType(raw, dialect) {
+    const name = raw.name;
+    const first = toInteger(raw.args[0]);
+    const second = toInteger(raw.args[1]);
+    if (raw.enumValues !== undefined) {
+        return { type: 'string' };
+    }
+    if (raw.setValues !== undefined) {
+        return { type: 'text' };
+    }
+    const serial = SERIAL_NAMES[name];
+    if (serial !== undefined && dialect !== 'sqlite') {
+        return {
+            type: dialect === 'mysql' && name === 'serial' ? 'bigInt' : serial,
+            autoIncrement: true,
+        };
+    }
+    if (name === 'bool' || name === 'boolean') {
+        return { type: 'boolean' };
+    }
+    if (name === 'bit') {
+        if (raw.args.length === 0 || first === 1) {
+            return { type: 'boolean' };
+        }
+        return { type: 'unsupported', unsupported: true };
+    }
+    if (name === 'tinyint' && dialect === 'mysql' && first === 1) {
+        return { type: 'boolean' };
+    }
+    if (INT_NAMES.has(name)) {
+        return { type: 'int' };
+    }
+    if (BIG_INT_NAMES.has(name)) {
+        return { type: 'bigInt' };
+    }
+    if (FLOAT_NAMES.has(name)) {
+        return { type: 'float' };
+    }
+    if (DECIMAL_NAMES.has(name)) {
+        return {
+            type: 'decimal',
+            ...(first === undefined ? {} : { maxDigits: first }),
+            ...(first === undefined ? {} : { decimalPlaces: second ?? 0 }),
+        };
+    }
+    if (name === 'money' || name === 'smallmoney') {
+        if (dialect === 'sqlserver') {
+            return {
+                type: 'decimal',
+                maxDigits: name === 'money' ? 19 : 10,
+                decimalPlaces: 4,
+            };
+        }
+        return { type: 'unsupported', unsupported: true };
+    }
+    if (STRING_NAMES.has(name)) {
+        if (raw.args[0]?.toLowerCase() === 'max' || first === undefined) {
+            return { type: 'text' };
+        }
+        return { type: 'string', maxLength: first };
+    }
+    if (FIXED_CHAR_NAMES.has(name)) {
+        if (raw.args[0]?.toLowerCase() === 'max') {
+            return { type: 'text' };
+        }
+        if (first === undefined) {
+            return dialect === 'sqlite'
+                ? { type: 'text' }
+                : { type: 'string', maxLength: 1 };
+        }
+        return { type: 'string', maxLength: first };
+    }
+    if (TEXT_NAMES.has(name)) {
+        return { type: 'text' };
+    }
+    if (name === 'json' || name === 'jsonb') {
+        return { type: 'json' };
+    }
+    if (name === 'timestamp' && dialect === 'sqlserver') {
+        return { type: 'unsupported', unsupported: true };
+    }
+    if (name === 'rowversion') {
+        return { type: 'unsupported', unsupported: true };
+    }
+    if (DATE_TIME_NAMES.has(name)) {
+        return { type: 'dateTime' };
+    }
+    if (name === 'date') {
+        return { type: 'date' };
+    }
+    if (name === 'time' || name === 'timetz') {
+        return { type: 'time' };
+    }
+    if (name === 'interval' || name.startsWith('interval ')) {
+        return { type: 'duration' };
+    }
+    if (name === 'uuid' || name === 'uniqueidentifier') {
+        return { type: 'uuid' };
+    }
+    if (BYTES_NAMES.has(name)) {
+        return { type: 'bytes' };
+    }
+    if (name === 'inet' || name === 'cidr') {
+        return { type: 'ipAddress' };
+    }
+    if (name === 'hstore') {
+        return { type: 'hstore' };
+    }
+    const rangeOf = RANGE_NAMES[name];
+    if (rangeOf !== undefined) {
+        return { type: 'range', rangeOf };
+    }
+    if (dialect === 'sqlite') {
+        const affinity = mapSqliteAffinity(name);
+        if (affinity !== undefined) {
+            return affinity;
+        }
+        if (name === '') {
+            return { type: 'bytes' };
+        }
+        return { type: 'decimal' };
+    }
+    return { type: 'unsupported', unsupported: true, isUserType: true };
+}
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+const NOW_FUNCTIONS = new Set([
+    'CURRENT_TIMESTAMP',
+    'CURRENT_DATE',
+    'CURRENT_TIME',
+    'LOCALTIMESTAMP',
+    'LOCALTIME',
+    'NOW',
+    'GETDATE',
+    'GETUTCDATE',
+    'SYSDATETIME',
+    'SYSUTCDATETIME',
+    'SYSDATETIMEOFFSET',
+    'TRANSACTION_TIMESTAMP',
+    'STATEMENT_TIMESTAMP',
+    'CLOCK_TIMESTAMP',
+]);
+const UUID_FUNCTIONS = new Set([
+    'GEN_RANDOM_UUID',
+    'UUID_GENERATE_V4',
+    'UUID_GENERATE_V1',
+    'UUID_GENERATE_V1MC',
+    'NEWID',
+    'NEWSEQUENTIALID',
+    'UUID',
+    'UUID_V4',
+    'UUIDV4',
+]);
+const SQLITE_NOW_FUNCTIONS = new Set([
+    'DATETIME',
+    'DATE',
+    'TIME',
+    'JULIANDAY',
+]);
+/** Layers of wrapping parentheses removed from a default; more than this is never a real default. */
+const MAX_STRIPPED_LAYERS = 32;
+/** Removes parentheses that wrap the whole expression: `((0))` becomes `0`. */
+function stripOuterParens(tokens) {
+    let from = 0;
+    let to = tokens.length;
+    for (let layer = 0; layer < MAX_STRIPPED_LAYERS; layer += 1) {
+        const first = tokens[from];
+        const last = tokens[to - 1];
+        if (to - from < 2 ||
+            first === undefined ||
+            last === undefined ||
+            first.text !== '(' ||
+            first.kind !== 'punct' ||
+            last.text !== ')' ||
+            last.kind !== 'punct') {
+            break;
+        }
+        let depth = 0;
+        let wrapsAll = true;
+        for (let at = from; at < to; at += 1) {
+            const token = tokens[at];
+            if (token?.kind === 'punct') {
+                if (token.text === '(') {
+                    depth += 1;
+                }
+                else if (token.text === ')') {
+                    depth -= 1;
+                    if (depth === 0 && at < to - 1) {
+                        wrapsAll = false;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!wrapsAll) {
+            break;
+        }
+        from += 1;
+        to -= 1;
+    }
+    return from === 0 && to === tokens.length ? tokens : tokens.slice(from, to);
+}
+/** True when what follows a literal is only a type cast: `::character varying`, `::text[]`, `::"public"."x"`. */
+function isCastOnly(tokens) {
+    const first = tokens[0];
+    if (first === undefined) {
+        return true;
+    }
+    if (first.kind !== 'punct' || first.text !== '::') {
+        return false;
+    }
+    return tokens.every((token) => token.kind === 'word' ||
+        token.kind === 'ident' ||
+        token.kind === 'number' ||
+        (token.kind === 'punct' && /^(::|\(|\)|,|\.|\[|\])$/.test(token.text)));
+}
+function numberLiteral(text) {
+    const value = Number(text);
+    if (Number.isFinite(value) &&
+        String(value) !== '' &&
+        /^[+-]?\d+(\.\d+)?$/.test(text)) {
+        const normalized = text
+            .replace(/^\+/, '')
+            .replace(/^(-?)0+(?=\d)/, '$1');
+        const canonical = String(value);
+        if (canonical === normalized ||
+            (normalized.includes('.') &&
+                canonical === normalized.replace(/0+$/, '').replace(/\.$/, ''))) {
+            return value;
+        }
+    }
+    return text;
+}
+/**
+ * Reads a DEFAULT expression. Returns `null` for `DEFAULT NULL` (no default at all), and `undefined` for an
+ * expression the model cannot describe, which the caller keeps as a raw database expression.
+ */
+export function interpretDefault(allTokens, target, dialect) {
+    const tokens = stripOuterParens(allTokens);
+    const first = tokens[0];
+    if (first === undefined) {
+        return null;
+    }
+    const stringish = target.type === 'string' ||
+        target.type === 'text' ||
+        target.type === 'uuid' ||
+        target.type === 'json' ||
+        target.type === 'dateTime' ||
+        target.type === 'date' ||
+        target.type === 'time' ||
+        target.type === 'duration' ||
+        target.type === 'ipAddress';
+    if (first.kind === 'word' && first.up === 'NULL' && tokens.length === 1) {
+        return null;
+    }
+    // Booleans and numbers.
+    if (first.kind === 'word' && (first.up === 'TRUE' || first.up === 'FALSE')) {
+        if (tokens.length === 1 && !target.isArray) {
+            if (target.type === 'boolean') {
+                return { kind: 'literal', value: first.up === 'TRUE' };
+            }
+            if (target.type === 'int' || target.type === 'bigInt') {
+                return { kind: 'literal', value: first.up === 'TRUE' ? 1 : 0 };
+            }
+        }
+        return undefined;
+    }
+    let signed = '';
+    let numberToken;
+    if (first.kind === 'number' && tokens.length === 1) {
+        numberToken = first;
+    }
+    else if (first.kind === 'punct' &&
+        (first.text === '-' || first.text === '+') &&
+        tokens.length === 2 &&
+        tokens[1]?.kind === 'number') {
+        signed = first.text === '-' ? '-' : '';
+        numberToken = tokens[1];
+    }
+    if (numberToken !== undefined && !target.isArray) {
+        const text = `${signed}${numberToken.value}`;
+        if (target.type === 'boolean') {
+            if (text === '1') {
+                return { kind: 'literal', value: true };
+            }
+            if (text === '0') {
+                return { kind: 'literal', value: false };
+            }
+            return undefined;
+        }
+        if (target.type === 'int' ||
+            target.type === 'bigInt' ||
+            target.type === 'float' ||
+            target.type === 'decimal') {
+            return { kind: 'literal', value: numberLiteral(text) };
+        }
+        if (stringish && target.enumType === undefined) {
+            return { kind: 'literal', value: text };
+        }
+        return undefined;
+    }
+    // String literals, optionally cast.
+    if (first.kind === 'string' && !target.isArray) {
+        const rest = tokens.slice(1);
+        if (isCastOnly(rest)) {
+            const value = first.value;
+            if (target.enumType !== undefined) {
+                const member = target.enumType.values.find((candidate) => candidate.dbValue === value);
+                if (member !== undefined) {
+                    return { kind: 'enumValue', value: member.name };
+                }
+                return undefined;
+            }
+            if (target.type === 'boolean') {
+                const lowered = value.toLowerCase();
+                if (['t', 'true', '1', 'y', 'yes', 'on'].includes(lowered)) {
+                    return { kind: 'literal', value: true };
+                }
+                if (['f', 'false', '0', 'n', 'no', 'off'].includes(lowered)) {
+                    return { kind: 'literal', value: false };
+                }
+                return undefined;
+            }
+            if (target.type === 'int' ||
+                target.type === 'bigInt' ||
+                target.type === 'float' ||
+                target.type === 'decimal') {
+                if (/^[+-]?\d+(\.\d+)?$/.test(value.trim())) {
+                    return { kind: 'literal', value: numberLiteral(value.trim()) };
+                }
+                return undefined;
+            }
+            if ((target.type === 'dateTime' ||
+                target.type === 'date' ||
+                target.type === 'time') &&
+                value.toLowerCase() === 'now') {
+                return { kind: 'now' };
+            }
+            if (stringish) {
+                return { kind: 'literal', value };
+            }
+        }
+        return undefined;
+    }
+    // Function calls and keywords.
+    if (first.kind === 'word') {
+        const callGroup = tokens.length === 1 ||
+            (tokens[1]?.kind === 'punct' &&
+                tokens[1].text === '(' &&
+                tokens[tokens.length - 1]?.text === ')' &&
+                tokens[tokens.length - 1]?.kind === 'punct');
+        if (callGroup && NOW_FUNCTIONS.has(first.up)) {
+            if (target.type === 'dateTime' ||
+                target.type === 'date' ||
+                target.type === 'time') {
+                return { kind: 'now' };
+            }
+        }
+        if (callGroup &&
+            UUID_FUNCTIONS.has(first.up) &&
+            (target.type === 'uuid' || target.type === 'string')) {
+            return { kind: 'uuid' };
+        }
+        if (callGroup &&
+            first.up === 'NEXTVAL' &&
+            (target.type === 'int' || target.type === 'bigInt')) {
+            return { kind: 'autoIncrement' };
+        }
+        if (dialect === 'sqlite' &&
+            SQLITE_NOW_FUNCTIONS.has(first.up) &&
+            tokens[1]?.text === '(' &&
+            tokens[2]?.kind === 'string' &&
+            tokens[2].value.toLowerCase() === 'now' &&
+            tokens.slice(3).every((token) => token.kind !== 'word') &&
+            (target.type === 'dateTime' ||
+                target.type === 'date' ||
+                target.type === 'time')) {
+            return { kind: 'now' };
+        }
+    }
+    return undefined;
+}
+/** The raw expression of a default that is kept as written (parentheses around the whole text removed). */
+export function defaultExpression(allTokens, text) {
+    return sourceOf(text, stripOuterParens(allTokens));
+}
+//# sourceMappingURL=sqlTypes.js.map