ormbridge 0.10.0 → 0.12.0

package/dist/emitters/sqlDdl.js

@@ -1,6 +1,8 @@
 import { findModel } from '../ir.js';
 import { limitIdentifier, toSnakeCase } from '../naming.js';
 import { expandManyToMany, normalizeSchema, } from '../transforms.js';
+import { COCKROACH_PREFIX, cockroachMissingType, cockroachSequentialWarning, } from './cockroach.js';
+import { emitClickhouseDdl } from './sqlClickhouse.js';
 /** The dialect a provider is written in. MongoDB has no SQL; CockroachDB speaks PostgreSQL. */
 export function sqlDialectOf(provider) {
     switch (provider) {
@@ -91,6 +93,10 @@ export function quoteIdentifier(dialect, name) {
     }
     return quoteAlways(dialect, name);
 }
+/** The name of the database in messages: CockroachDB shares the PostgreSQL dialect but not its limits. */
+function labelOf(context) {
+    return context.cockroach ? 'CockroachDB' : DIALECT_LABELS[context.dialect];
+}
 function quoteAlways(dialect, name) {
     switch (dialect) {
         case 'mysql':
@@ -260,14 +266,19 @@ const UUID_DEFAULTS = {
 // Entry point
 // ---------------------------------------------------------------------------
 export function emitSqlDdl(schema, options) {
+    if (options.provider === 'clickhouse') {
+        return emitClickhouseDdl(schema, options.naming);
+    }
     // The join table of a many-to-many field is an ordinary table in SQL.
     const expanded = expandManyToMany(schema);
     const prepared = options.naming === 'normalize' ? normalizeSchema(expanded) : expanded;
     const dialect = sqlDialectOf(options.provider);
     const context = {
         dialect,
+        cockroach: options.provider === 'cockroachdb',
         schema: prepared,
         warnings: [],
+        sequentialKeys: [],
         enums: new Map(),
         names: new Set(),
         unexpressedAutoUpdates: [],
@@ -296,8 +307,11 @@ export function emitSqlDdl(schema, options) {
     for (const view of views) {
         context.warnings.push(`${view.name}: this is a database view; the schema has no SQL definition for it, so only a commented placeholder was written.`);
     }
+    if (context.sequentialKeys.length > 0) {
+        context.warnings.push(cockroachSequentialWarning(context.sequentialKeys, 'written as GENERATED BY DEFAULT AS IDENTITY, which CockroachDB backs with a sequence (SERIAL would be unique_rowid(): 64-bit and not consecutive)'));
+    }
     if (context.unexpressedAutoUpdates.length > 0) {
-        context.warnings.push(`${DIALECT_LABELS[dialect]} cannot refresh a column on update from the DDL (${context.unexpressedAutoUpdates.join(', ')}); the application or a trigger has to set it.`);
+        context.warnings.push(`${labelOf(context)} cannot refresh a column on update from the DDL (${context.unexpressedAutoUpdates.join(', ')}); the application or a trigger has to set it.`);
     }
     return { text: render(context, ordered, views), warnings: context.warnings };
 }
@@ -306,7 +320,7 @@ function warnAboutProvider(context, provider) {
         context.warnings.push('Provider "mongodb": MongoDB has no SQL schema; PostgreSQL DDL was written.');
     }
     else if (provider === 'cockroachdb') {
-        context.warnings.push('Provider "cockroachdb": PostgreSQL DDL was written, which CockroachDB accepts; check the types it maps differently.');
+        context.warnings.push(`${COCKROACH_PREFIX} PostgreSQL-compatible DDL was written for CockroachDB: integers are sized explicitly (INT4, INT2, INT8) because a bare INT is 64-bit there, and PostgreSQL-only types and index methods are replaced and reported below.`);
     }
 }
 function warnAboutIgnoredConstructs(context) {
@@ -348,7 +362,7 @@ function generatedName(context, table, columns, suffix) {
 function checkIdentifierLength(context, label, name) {
     const max = MAX_IDENTIFIER[context.dialect];
     if (context.dialect !== 'sqlite' && name.length > max) {
-        context.warnings.push(`${label}: the name "${name}" is longer than the ${max} characters ${DIALECT_LABELS[context.dialect]} allows in an identifier.`);
+        context.warnings.push(`${label}: the name "${name}" is longer than the ${max} characters ${labelOf(context)} allows in an identifier.`);
     }
 }
 function resolveEnums(context, naming) {
@@ -408,6 +422,29 @@ function nativeTypeSql(dialect, field) {
     const [first, ...rest] = known.split(' ');
     return `${first ?? known}(${args.join(', ')})${rest.length > 0 ? ` ${rest.join(' ')}` : ''}`;
 }
+/**
+ * CockroachDB's reading of a Prisma `@db.*` native type, for the types that differ from PostgreSQL:
+ * `Integer` is spelled INT4 (a bare INTEGER is 64-bit), `Money` and `Xml` do not exist, and `Json` is
+ * stored as JSONB.
+ */
+function cockroachNativeType(context, label, field) {
+    const name = field.nativeType?.name.toLowerCase();
+    switch (name) {
+        case 'integer':
+            return plainType('INT4', field);
+        case 'money':
+            context.warnings.push(`${label}: CockroachDB has no MONEY type; the column was written as NUMERIC(19, 4).`);
+            return plainType('NUMERIC(19, 4)', field);
+        case 'xml':
+            context.warnings.push(`${label}: CockroachDB has no XML type; the column was written as TEXT.`);
+            return { ...plainType('TEXT', field), textual: true, storage: 'text' };
+        case 'json':
+            context.warnings.push(`${label}: CockroachDB stores JSON as JSONB (key order and duplicate keys are not kept); the column was written as JSONB.`);
+            return { ...plainType('JSONB', field), textual: true };
+        default:
+            return undefined;
+    }
+}
 function storageOf(type) {
     switch (type) {
         case 'text':
@@ -437,6 +474,10 @@ function columnType(context, label, field, columnSql) {
     if (depth === 0) {
         return element;
     }
+    if (context.cockroach && (depth > 1 || element.storage === 'json')) {
+        context.warnings.push(`${label}: CockroachDB has no ${depth > 1 ? 'multi-dimensional arrays' : 'arrays of JSON'}; the column was written as JSONB.`);
+        return jsonColumnType(context, columnSql, 'an array stored as JSON');
+    }
     if (context.dialect === 'postgresql') {
         return {
             ...element,
@@ -444,7 +485,7 @@ function columnType(context, label, field, columnSql) {
             storage: 'other',
         };
     }
-    const label2 = DIALECT_LABELS[context.dialect];
+    const label2 = labelOf(context);
     context.warnings.push(`${label}: ${label2} has no array column type; the array was written as a JSON ${context.dialect === 'sqlite' ? 'text ' : ''}column.`);
     return jsonColumnType(context, columnSql, 'an array stored as JSON');
 }
@@ -498,6 +539,12 @@ function scalarColumnType(context, label, field, columnSql, isArrayElement) {
     if (enumInfo !== undefined) {
         return enumColumnType(context, enumInfo, columnSql, isArrayElement);
     }
+    if (context.cockroach) {
+        const cockroachNative = cockroachNativeType(context, label, field);
+        if (cockroachNative !== undefined) {
+            return cockroachNative;
+        }
+    }
     const native = nativeTypeSql(dialect, field);
     if (native !== undefined) {
         return {
@@ -534,7 +581,12 @@ function scalarColumnType(context, label, field, columnSql, isArrayElement) {
                 textual: true,
             };
         case 'int':
-            return plainType(dialect === 'mysql' || dialect === 'sqlserver' ? 'INT' : 'INTEGER', field);
+            // A bare INT (INTEGER) is 64-bit on CockroachDB, so the 32-bit IR type is spelled INT4.
+            return plainType(context.cockroach
+                ? 'INT4'
+                : dialect === 'mysql' || dialect === 'sqlserver'
+                    ? 'INT'
+                    : 'INTEGER', field);
         case 'bigInt':
             return plainType('BIGINT', field);
         case 'float':
@@ -581,7 +633,7 @@ function scalarColumnType(context, label, field, columnSql, isArrayElement) {
             if (dialect === 'postgresql') {
                 return plainType('INTERVAL', field);
             }
-            context.warnings.push(`${label}: ${DIALECT_LABELS[dialect]} has no interval type; the duration was written as an integer (microseconds).`);
+            context.warnings.push(`${label}: ${labelOf(context)} has no interval type; the duration was written as an integer (microseconds).`);
             return {
                 ...plainType(dialect === 'sqlite' ? 'INTEGER' : 'BIGINT', field),
                 comment: 'duration in microseconds',
@@ -598,6 +650,10 @@ function scalarColumnType(context, label, field, columnSql, isArrayElement) {
                 textual: true,
             };
         case 'hstore':
+            if (context.cockroach) {
+                context.warnings.push(`${label}: CockroachDB has no hstore type; the column was written as JSONB.`);
+                return jsonColumnType(context, columnSql, 'hstore stored as JSONB');
+            }
             if (dialect === 'postgresql') {
                 context.needsHstore = true;
                 return { ...plainType('HSTORE', field), textual: true };
@@ -666,7 +722,7 @@ function decimalType(context, label, field) {
     }
     const limit = dialect === 'mysql' ? 65 : dialect === 'sqlserver' ? 38 : undefined;
     if (precision !== undefined && limit !== undefined && precision > limit) {
-        context.warnings.push(`${label}: ${DIALECT_LABELS[dialect]} allows at most ${limit} digits in a decimal; ${precision} was reduced to ${limit}.`);
+        context.warnings.push(`${label}: ${labelOf(context)} allows at most ${limit} digits in a decimal; ${precision} was reduced to ${limit}.`);
         precision = limit;
         if (scale !== undefined && scale > limit) {
             scale = limit;
@@ -689,6 +745,14 @@ function decimalType(context, label, field) {
     ]);
 }
 function rangeColumnType(context, label, field) {
+    if (context.cockroach) {
+        context.warnings.push(`${label}: CockroachDB has no range types (int4range, tstzrange, ...); the column was written as text.`);
+        return {
+            ...plainType('TEXT', field),
+            comment: 'range stored as text',
+            textual: true,
+        };
+    }
     if (context.dialect === 'postgresql') {
         return {
             ...plainType(POSTGRES_RANGE_TYPES[field.rangeOf ?? 'int'] ?? 'INT4RANGE', field),
@@ -711,7 +775,18 @@ function rangeColumnType(context, label, field) {
 }
 function unsupportedColumnType(context, label, field) {
     if (field.unsupportedType !== undefined && field.unsupportedType !== '') {
-        context.warnings.push(`${label}: the database type "${field.unsupportedType}" (Prisma Unsupported) was written as it is; check that ${DIALECT_LABELS[context.dialect]} has it.`);
+        const missing = context.cockroach
+            ? cockroachMissingType(field.unsupportedType)
+            : undefined;
+        if (missing !== undefined) {
+            context.warnings.push(`${label}: CockroachDB has no ${missing} type; "${field.unsupportedType}" was written as it is, so CREATE TABLE fails until the column type is changed.`);
+            return {
+                ...plainType(field.unsupportedType, field),
+                storage: 'other',
+                textual: false,
+            };
+        }
+        context.warnings.push(`${label}: the database type "${field.unsupportedType}" (Prisma Unsupported) was written as it is; check that ${labelOf(context)} has it.`);
         return {
             ...plainType(field.unsupportedType, field),
             storage: 'other',
@@ -885,11 +960,15 @@ function defaultSql(context, label, field, type) {
             if (value.isFunction === true) {
                 return dropped(`the ${value.expression} default function has no SQL equivalent`);
             }
+            if (context.cockroach &&
+                value.expression.replace(/\s+/g, '').toLowerCase() === 'unique_rowid()') {
+                return 'unique_rowid()';
+            }
             const known = knownExpression(dialect, field, value.expression, type);
             if (known !== undefined) {
                 return known;
             }
-            context.warnings.push(`${label}: the database default expression ${value.expression} was written as it is; check that ${DIALECT_LABELS[dialect]} accepts it.`);
+            context.warnings.push(`${label}: the database default expression ${value.expression} was written as it is; check that ${labelOf(context)} accepts it.`);
             const expression = value.expression.trim();
             return expression.startsWith('(') ? expression : `(${expression})`;
         }
@@ -979,6 +1058,12 @@ function literalDefault(context, label, field, value, type) {
         case 'bytes':
             return dropped('a literal default on a binary column cannot be written');
         case 'hstore': {
+            if (context.cockroach) {
+                const asJson = parseJson(text);
+                return asJson.ok
+                    ? `${sqlStringLiteral(dialect, JSON.stringify(asJson.value))}::jsonb`
+                    : dropped(`the value ${text} is not JSON`);
+            }
             if (dialect === 'postgresql') {
                 return text === '{}'
                     ? "''::hstore"
@@ -1002,7 +1087,7 @@ function isIntegerKey(field) {
     return field.type === 'int' || field.type === 'bigInt';
 }
 /** Resolves the column a foreign key points at: `toField`, otherwise the target's single-column key. */
-function resolveTarget(context, target, toField, depth = 0) {
+export function resolveTarget(context, target, toField, depth = 0) {
     if (depth > 5) {
         return undefined;
     }
@@ -1053,7 +1138,7 @@ function resolveRelationColumn(context, owner, relation, depth) {
 // ---------------------------------------------------------------------------
 // Tables
 // ---------------------------------------------------------------------------
-function columnNameOf(model, name) {
+export function columnNameOf(model, name) {
     const relation = model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.name === name) ??
         model.relations.find((candidate) => candidate.kind !== 'manyToMany' && candidate.columnName === name);
     const field = model.fields.find((candidate) => candidate.name === name) ??
@@ -1061,8 +1146,15 @@ function columnNameOf(model, name) {
     // A field wins over a relation of the same name: the field is the column the key is written on.
     return field?.columnName ?? relation?.columnName;
 }
-function isAutoIncrement(field) {
-    return field.default?.kind === 'autoIncrement';
+function isAutoIncrement(context, field) {
+    if (field.default?.kind === 'autoIncrement') {
+        return true;
+    }
+    // Prisma's CockroachDB `sequence()` default is the SERIAL of that database.
+    return (context.cockroach &&
+        field.default?.kind === 'dbExpression' &&
+        field.default.isFunction === true &&
+        /^sequence\(/i.test(field.default.expression));
 }
 function buildTable(context, model) {
     const dialect = context.dialect;
@@ -1226,7 +1318,7 @@ function buildColumn(context, label, field, columnName, inKey, singleColumnKey)
         notes.push('generated column written as a regular column');
     }
     let autoIncrement = false;
-    if (isAutoIncrement(field)) {
+    if (isAutoIncrement(context, field)) {
         if (!isIntegerKey(field)) {
             context.warnings.push(`${label}: an auto-increment default on a ${field.type} column cannot be written; it was dropped.`);
         }
@@ -1238,6 +1330,9 @@ function buildColumn(context, label, field, columnName, inKey, singleColumnKey)
         }
         else {
             autoIncrement = true;
+            if (context.cockroach) {
+                context.sequentialKeys.push(label);
+            }
         }
     }
     let sqlType = type.sql;
@@ -1254,6 +1349,11 @@ function buildColumn(context, label, field, columnName, inKey, singleColumnKey)
             onUpdate = mysqlCurrentTimestamp(type.sql);
             defaultText ??= onUpdate;
         }
+        else if (context.cockroach && field.type === 'dateTime') {
+            // CockroachDB (unlike PostgreSQL) has column-level ON UPDATE.
+            onUpdate = NOW_DEFAULTS[dialect].dateTime;
+            defaultText ??= onUpdate;
+        }
         else {
             context.unexpressedAutoUpdates.push(label);
         }
@@ -1442,7 +1542,10 @@ function indexColumnSql(context, table, label, column, options) {
     else if (options?.length !== undefined) {
         context.warnings.push(`${label}: the prefix length of "${column}" is only supported by MySQL and was dropped.`);
     }
-    if (context.dialect === 'postgresql' && options?.ops !== undefined) {
+    if (context.cockroach && options?.ops !== undefined) {
+        context.warnings.push(`${label}: CockroachDB supports only trigram operator classes on inverted indexes; the operator class of "${column}" was dropped.`);
+    }
+    else if (context.dialect === 'postgresql' && options?.ops !== undefined) {
         const raw = /^raw\(\s*["'](.*)["']\s*\)$/.exec(options.ops);
         text += ` ${raw?.[1] ?? toSnakeCase(options.ops)}`;
     }
@@ -1476,7 +1579,7 @@ function buildIndexes(context, table) {
         const blocked = columns.find((column) => table.columns.find((candidate) => candidate.name === column)
             ?.unindexable === true);
         if (blocked !== undefined) {
-            context.warnings.push(`${label}: ${DIALECT_LABELS[dialect]} cannot index the column "${blocked}" (its type is unbounded or JSON); the index was skipped.`);
+            context.warnings.push(`${label}: ${labelOf(context)} cannot index the column "${blocked}" (its type is unbounded or JSON); the index was skipped.`);
             continue;
         }
         const name = claimName(context, index.name ??
@@ -1499,7 +1602,7 @@ function buildIndexes(context, table) {
         const blocked = unique.columns.find((column) => table.columns.find((candidate) => candidate.name === column)
             ?.unindexable === true);
         if (blocked !== undefined) {
-            context.warnings.push(`${model.name}.${blocked}: ${DIALECT_LABELS[dialect]} cannot index the column "${blocked}" (its type is unbounded or JSON); the unique constraint was skipped.`);
+            context.warnings.push(`${model.name}.${blocked}: ${labelOf(context)} cannot index the column "${blocked}" (its type is unbounded or JSON); the unique constraint was skipped.`);
         }
         return blocked === undefined;
     });
@@ -1532,12 +1635,13 @@ function indexStatement(context, table, label, index, name, columns, entries) {
             return `CREATE FULLTEXT INDEX ${nameSql} ON ${tableSql} (${list});`;
         }
         if (dialect === 'postgresql') {
+            // CockroachDB builds the same inverted index over to_tsvector() (checked on v26.3).
             const vector = columns
                 .map((column) => `coalesce(${quote(context, column)}::text, '')`)
                 .join(" || ' ' || ");
             return `CREATE INDEX ${nameSql} ON ${tableSql} USING gin (to_tsvector('simple', ${vector}));`;
         }
-        context.warnings.push(`${label}: ${DIALECT_LABELS[dialect]} full-text search needs a separate mechanism (a virtual table or a catalog); it was written as an ordinary index.`);
+        context.warnings.push(`${label}: ${labelOf(context)} full-text search needs a separate mechanism (a virtual table or a catalog); it was written as an ordinary index.`);
     }
     const parts = ['CREATE'];
     if (index.isUnique) {
@@ -1555,7 +1659,23 @@ function indexStatement(context, table, label, index, name, columns, entries) {
     let trailing = '';
     if (index.method !== undefined) {
         const method = index.method.toUpperCase();
-        if (dialect === 'postgresql') {
+        if (context.cockroach) {
+            const last = columns[columns.length - 1];
+            const lastType = table.columns.find((candidate) => candidate.name === last)
+                ?.sqlType ?? '';
+            if (method === 'GIN') {
+                if (/JSONB|\[\]$|TSVECTOR|GEOMETRY|GEOGRAPHY/i.test(lastType)) {
+                    target = `${tableSql} USING gin`;
+                }
+                else {
+                    context.warnings.push(`${label}: CockroachDB builds an inverted (GIN) index only over JSONB, array, tsvector or spatial columns; "${last ?? ''}" is ${lastType}, so an ordinary index was written.`);
+                }
+            }
+            else if (method !== 'BTREE') {
+                context.warnings.push(`${label}: CockroachDB has no ${index.method} indexes (only B-tree and inverted GIN); an ordinary index was written${method === 'HASH' ? ' (CREATE INDEX ... USING HASH is a hash-sharded B-tree there, a different feature)' : ''}.`);
+            }
+        }
+        else if (dialect === 'postgresql') {
             target = `${tableSql} USING ${method.toLowerCase()}`;
         }
         else if (dialect === 'mysql' &&
@@ -1564,7 +1684,7 @@ function indexStatement(context, table, label, index, name, columns, entries) {
         }
         else if (method !== 'BTREE') {
             // B-tree is what every database builds anyway.
-            context.warnings.push(`${label}: the index type ${index.method} is not supported by ${DIALECT_LABELS[dialect]} and was dropped.`);
+            context.warnings.push(`${label}: the index type ${index.method} is not supported by ${labelOf(context)} and was dropped.`);
         }
     }
     parts.push('INDEX', nameSql, 'ON', target);
@@ -1698,7 +1818,7 @@ function renderView(context, view) {
 function render(context, ordered, views) {
     const dialect = context.dialect;
     const blocks = [
-        `-- SQL DDL for ${DIALECT_LABELS[dialect]}, generated by ormbridge.`,
+        `-- SQL DDL for ${labelOf(context)}, generated by ormbridge.`,
     ];
     if (dialect === 'sqlite') {
         blocks.push('PRAGMA foreign_keys = ON;');