@mikro-orm/sql 7.1.0-dev.9 → 7.1.0

package/schema/partitioning.js

@@ -0,0 +1,326 @@
+import { splitCommaSeparatedIdentifiers } from '@mikro-orm/core';
+export { splitCommaSeparatedIdentifiers };
+const skipQuotedLiteral = (value, start) => {
+    let i = start + 1;
+    while (i < value.length) {
+        if (value[i] === "'") {
+            if (value[i + 1] === "'") {
+                i += 2;
+                continue;
+            }
+            return i;
+        }
+        i++;
+    }
+    // Unterminated literal — point past the end so callers' `slice(start, end + 1)` includes
+    // the full remaining tail instead of dropping its last character.
+    return value.length;
+};
+/**
+ * Apply `transform` only to segments of `value` that lie outside single-quoted
+ * SQL literals, leaving literal content (including escaped `''`) untouched.
+ */
+const mapOutsideLiterals = (value, transform) => {
+    let ret = '';
+    let buffer = '';
+    let i = 0;
+    while (i < value.length) {
+        if (value[i] === "'") {
+            ret += transform(buffer);
+            buffer = '';
+            const end = skipQuotedLiteral(value, i);
+            ret += value.slice(i, end + 1);
+            i = end + 1;
+            continue;
+        }
+        buffer += value[i];
+        i++;
+    }
+    return ret + transform(buffer);
+};
+const collapseWhitespace = (value) => value.replace(/\s+/g, ' ');
+const normalizeWhitespace = (value) => mapOutsideLiterals(value, collapseWhitespace).trim();
+const stripDoubleQuotes = (value) => mapOutsideLiterals(value, s => s.replaceAll('"', ''));
+const normalizeQuotedIdentifiers = (value) => stripDoubleQuotes(normalizeWhitespace(value));
+const findMatchingParenthesis = (value, start) => {
+    let depth = 0;
+    for (let i = start; i < value.length; i++) {
+        if (value[i] === "'") {
+            i = skipQuotedLiteral(value, i);
+            continue;
+        }
+        if (value[i] === '(') {
+            depth++;
+            continue;
+        }
+        if (value[i] === ')') {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+};
+const normalizePartitionLiterals = (value) => value
+    // PG pg_get_expr output often tacks `::text` onto string literals inside expressions; drop it
+    // so the catalog shape matches user-provided bounds. This applies symmetrically to both
+    // user metadata and catalog reads, so diffing converges. If a user intentionally writes a
+    // `::text` cast in a bound literal it will be stripped on both sides as well.
+    .replace(/('(?:[^']|'')*')::text\b/gi, '$1')
+    // Strip the `00:00:00` time component so catalog round-trips (timestamp[tz] bounds formatted
+    // via the session TimeZone) match user metadata that omitted the time part. Only collapse
+    // when we can confidently attribute the literal to a timestamp column: either a numeric
+    // offset is present (timestamptz catalog output) or an explicit `::timestamp[tz]` cast
+    // follows the literal. Bare `'YYYY-MM-DD 00:00:00'` without offset/cast could just as easily
+    // be a text/varchar list-partition value, and collapsing it would produce false-negative
+    // diffs.
+    .replace(/'(\d{4}-\d{2}-\d{2}) 00:00:00[+-]\d{2}(?::\d{2})?'/g, "'$1'")
+    .replace(/'(\d{4}-\d{2}-\d{2}) 00:00:00'(?=\s*::\s*timestamp(?:tz)?(?:\s+(?:with|without)\s+time\s+zone)?\b)/gi, "'$1'");
+const unwrapOuterParentheses = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('(') || !trimmed.endsWith(')')) {
+        return trimmed;
+    }
+    if (findMatchingParenthesis(trimmed, 0) !== trimmed.length - 1) {
+        return trimmed;
+    }
+    return trimmed.slice(1, -1).trim();
+};
+const unwrapAllOuterParentheses = (value) => {
+    let current = value.trim();
+    while (current.startsWith('(')) {
+        const unwrapped = unwrapOuterParentheses(current);
+        if (unwrapped === current) {
+            break;
+        }
+        current = unwrapped;
+    }
+    return current;
+};
+const normalizePartitionSqlFragment = (value) => {
+    const normalized = stripDoubleQuotes(normalizeWhitespace(normalizePartitionLiterals(value)));
+    let ret = '';
+    for (let i = 0; i < normalized.length; i++) {
+        if (normalized[i] === "'") {
+            const end = skipQuotedLiteral(normalized, i);
+            ret += normalized.slice(i, end + 1);
+            i = end;
+            continue;
+        }
+        if (normalized[i] === '(') {
+            const end = findMatchingParenthesis(normalized, i);
+            if (end === -1) {
+                ret += normalized.slice(i);
+                break;
+            }
+            const inner = unwrapAllOuterParentheses(normalizePartitionSqlFragment(normalized.slice(i + 1, end)));
+            ret += `(${inner})`;
+            i = end;
+            continue;
+        }
+        ret += normalized[i];
+    }
+    return normalizeWhitespace(unwrapAllOuterParentheses(ret));
+};
+const unquoteIdentifier = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1).replaceAll('""', '"');
+    }
+    return trimmed;
+};
+/**
+ * Split a user-supplied partition name into `{ schema, name }`. Supports bare (`child`),
+ * schema-qualified (`schema.child`), and quoted (`"my.schema"."child"`) forms. Dots inside
+ * double-quoted identifiers are part of the identifier and do not split.
+ */
+const splitPartitionName = (name) => {
+    let depth = 0;
+    for (let i = 0; i < name.length; i++) {
+        const ch = name[i];
+        if (ch === '"') {
+            if (name[i + 1] === '"') {
+                i++;
+                continue;
+            }
+            depth = depth === 0 ? 1 : 0;
+            continue;
+        }
+        if (ch === '.' && depth === 0) {
+            return {
+                schema: unquoteIdentifier(name.slice(0, i)),
+                name: unquoteIdentifier(name.slice(i + 1)),
+            };
+        }
+    }
+    return { name: unquoteIdentifier(name) };
+};
+const resolvePartitionKey = (meta, key, quoteIdentifier) => {
+    const trimmed = key.trim().replaceAll('"', '');
+    if (!trimmed) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: empty partition key`);
+    }
+    const prop = meta.root.properties[trimmed] ??
+        Object.values(meta.root.properties).find(candidate => candidate.fieldNames?.length === 1 && candidate.fieldNames[0] === trimmed);
+    if (!prop) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: unknown partition key '${key.trim()}'`);
+    }
+    if (prop.fieldNames?.length !== 1) {
+        throw new Error(`Entity ${meta.className} has invalid partitionBy option: partition key '${key.trim()}' maps to multiple columns ('${prop.fieldNames?.join("', '")}'); list them explicitly as partition keys`);
+    }
+    return quoteIdentifier(prop.fieldNames[0]);
+};
+/**
+ * Resolve the partition expression to a SQL fragment. Column-reference forms (array of keys
+ * or a clean comma-list of identifiers) are rewritten to the backing `fieldNames` and passed
+ * through `quoteIdentifier`. The callback form and the raw-SQL fallback (anything that isn't
+ * a clean identifier list, e.g. `date_trunc('day', created_at)`) are emitted verbatim — the
+ * user owns identifier quoting inside a raw expression.
+ */
+const resolvePartitionExpression = (meta, expression, quoteIdentifier) => {
+    if (typeof expression === 'function') {
+        return normalizeWhitespace(expression(meta.createSchemaColumnMappingObject()));
+    }
+    if (Array.isArray(expression)) {
+        return expression.map(key => resolvePartitionKey(meta, key, quoteIdentifier)).join(', ');
+    }
+    const trimmed = expression.trim();
+    const keys = splitCommaSeparatedIdentifiers(trimmed);
+    if (keys) {
+        return keys.map(key => resolvePartitionKey(meta, key, quoteIdentifier)).join(', ');
+    }
+    return trimmed;
+};
+const createPartitionDefinition = (type, expression) => `${type.toLowerCase()} (${normalizeWhitespace(expression)})`;
+/** @internal */
+export function normalizePartitionDefinition(value) {
+    const normalized = normalizeWhitespace(value);
+    const match = /^(\w+)\s*(.*)$/.exec(normalized);
+    const rawType = match ? match[1] : normalized;
+    const type = rawType.toLowerCase();
+    const expression = match ? match[2].trim() : '';
+    if (!expression) {
+        return type;
+    }
+    if (!expression.startsWith('(')) {
+        return `${type} ${normalizePartitionSqlFragment(expression)}`;
+    }
+    return `${type} (${normalizePartitionSqlFragment(unwrapAllOuterParentheses(expression))})`;
+}
+const PARTITION_BOUND_KEYWORDS = /\b(for values|with|in|from|to|minvalue|maxvalue|null)\b/gi;
+/** @internal */
+export function normalizePartitionBound(value) {
+    const normalized = normalizeWhitespace(value);
+    if (!normalized) {
+        return '';
+    }
+    if (/^default$/i.test(normalized)) {
+        return 'default';
+    }
+    // Prepend `for values` if the caller passed a bare `with/in/from … to …` clause, then lowercase
+    // PG bound keywords outside quoted literals (so `FROM (MINVALUE) TO ('hello TO world')` becomes
+    // `from (minvalue) to ('hello TO world')` with the inner TO inside the literal preserved).
+    // PG's `pg_get_expr` emits `MINVALUE`/`MAXVALUE`/`NULL` in uppercase, so case-folding them here
+    // prevents a perpetual diff against user-supplied lowercase bounds.
+    const prefixed = /^for values\b/i.test(normalized) ? normalized : `for values ${normalized}`;
+    const lowered = mapOutsideLiterals(prefixed, segment => segment.replace(PARTITION_BOUND_KEYWORDS, match => match.toLowerCase()));
+    return normalizePartitionSqlFragment(lowered);
+}
+const createPartitionBound = (value) => normalizePartitionBound(value);
+const createHashPartitions = (tableName, tableSchema, partitions) => {
+    const count = typeof partitions === 'number' ? partitions : partitions.length;
+    return Array.from({ length: count }, (_, remainder) => {
+        const bound = normalizePartitionBound(`with (modulus ${count}, remainder ${remainder})`);
+        if (typeof partitions === 'number') {
+            return { name: `${tableName}_${remainder}`, schema: tableSchema, bound };
+        }
+        const { name, schema } = splitPartitionName(partitions[remainder]);
+        return { name, schema: schema ?? tableSchema, bound };
+    });
+};
+const createExplicitPartitions = (tableName, tableSchema, partitions) => partitions.map((partition, index) => {
+    const resolvedName = partition.name ?? `${tableName}_${index}`;
+    const { name, schema } = splitPartitionName(resolvedName);
+    return {
+        name,
+        schema: schema ?? tableSchema,
+        bound: createPartitionBound(partition.values),
+    };
+});
+/** @internal */
+export const getTablePartitioning = (meta, tableSchema, quoteIdentifier = id => id) => {
+    if (!meta.partitionBy) {
+        return undefined;
+    }
+    const definition = createPartitionDefinition(meta.partitionBy.type, resolvePartitionExpression(meta, meta.partitionBy.expression, quoteIdentifier));
+    const partitions = meta.partitionBy.type === 'hash'
+        ? createHashPartitions(meta.tableName, tableSchema, meta.partitionBy.partitions)
+        : createExplicitPartitions(meta.tableName, tableSchema, meta.partitionBy.partitions);
+    return { definition, partitions };
+};
+/** @internal */
+export const diffPartitioning = (from, to, defaultSchema) => {
+    if (!from && !to) {
+        return false;
+    }
+    if (!from || !to) {
+        return true;
+    }
+    if (normalizeQuotedIdentifiers(normalizePartitionDefinition(from.definition)) !==
+        normalizeQuotedIdentifiers(normalizePartitionDefinition(to.definition))) {
+        return true;
+    }
+    if (from.partitions.length !== to.partitions.length) {
+        return true;
+    }
+    const normalizeSchema = (schema) => (schema && schema !== defaultSchema ? schema : '');
+    const serializePartition = (partition) => `${normalizeSchema(partition.schema)}.${partition.name}:${normalizeQuotedIdentifiers(normalizePartitionBound(partition.bound))}`;
+    const fromPartitions = from.partitions.map(serializePartition).sort();
+    const toPartitions = to.partitions.map(serializePartition).sort();
+    return fromPartitions.some((partition, index) => partition !== toPartitions[index]);
+};
+const SUPPORTED_PARTITION_TYPES = ['hash', 'list', 'range'];
+const isSupportedPartitionType = (value) => SUPPORTED_PARTITION_TYPES.includes(value);
+/** @internal */
+export const toEntityPartitionBy = (partitioning, parentTableName, parentSchema) => {
+    if (!partitioning) {
+        return undefined;
+    }
+    const normalizedDefinition = normalizePartitionDefinition(partitioning.definition);
+    const normalizedPartitions = partitioning.partitions.map(partition => ({
+        ...partition,
+        bound: normalizePartitionBound(partition.bound),
+    }));
+    // Split the leading type keyword off of the definition without using `split(' ')`, which would
+    // shatter quoted literals containing spaces. Match a bareword prefix followed by whitespace.
+    const [, rawType = normalizedDefinition, rawExpression = ''] = /^(\S+)(?:\s+([\s\S]*))?$/.exec(normalizeWhitespace(normalizedDefinition)) ?? [];
+    const type = rawType.toLowerCase();
+    if (!isSupportedPartitionType(type)) {
+        throw new Error(`Unsupported partition type '${rawType}' in definition '${partitioning.definition}'`);
+    }
+    const expression = unwrapOuterParentheses(rawExpression);
+    const qualify = (partition) => partition.schema && partition.schema !== parentSchema ? `${partition.schema}.${partition.name}` : partition.name;
+    if (type === 'hash') {
+        // Collapse to a bare count when catalog names follow the default
+        // `${parentTableName}_${remainder}` pattern and live in the parent's schema, or when we have
+        // no parent context to compare against (backwards-compatible behavior for callers that pass
+        // just the `TablePartitioning`). Otherwise preserve the explicit name array so the next DDL
+        // generation reproduces the same children.
+        const usesDefaultShape = parentTableName == null ||
+            normalizedPartitions.every((p, i) => p.name === `${parentTableName}_${i}` && (!p.schema || p.schema === parentSchema));
+        return {
+            type,
+            expression,
+            partitions: usesDefaultShape ? normalizedPartitions.length : normalizedPartitions.map(qualify),
+        };
+    }
+    return {
+        type,
+        expression,
+        partitions: normalizedPartitions.map(partition => ({
+            name: qualify(partition),
+            values: partition.bound === 'default' ? 'default' : partition.bound.replace(/^for values\s+/i, ''),
+        })),
+    };
+};

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, Scalar, Type } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -44,6 +44,7 @@ export interface Column {
     default?: string | null;
     defaultConstraint?: string;
     comment?: string;
+    collation?: string;
     generated?: string;
     nativeEnumName?: string;
     enumItems?: string[];
@@ -51,7 +52,7 @@ export interface Column {
     unique?: boolean;
     /** mysql only */
     extra?: string;
-    ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
+    ignoreSchemaChanges?: ('type' | 'extra' | 'default' | 'collation')[];
 }
 export interface ForeignKey {
     columnNames: string[];
@@ -71,6 +72,11 @@ export interface IndexDef {
     primary: boolean;
     composite?: boolean;
     expression?: string;
+    /**
+     * WHERE predicate for partial indexes, normalized to a SQL fragment after metadata
+     * resolution and introspection. Mutually exclusive with `expression`.
+     */
+    where?: string;
     options?: Dictionary;
     type?: string | Readonly<{
         indexType?: string;
@@ -118,6 +124,44 @@ export interface SqlTriggerDef {
     when?: string;
     expression?: string;
 }
+/** Resolved routine definition for schema operations (callback bodies resolved to strings). */
+export interface SqlRoutineDef {
+    name: string;
+    schema?: string;
+    type: 'procedure' | 'function';
+    language?: string;
+    comment?: string;
+    security?: 'invoker' | 'definer';
+    definer?: string;
+    deterministic?: boolean;
+    dataAccess?: 'contains-sql' | 'no-sql' | 'reads-sql-data' | 'modifies-sql-data';
+    body?: string;
+    expression?: string;
+    returns?: {
+        type: string;
+        runtimeType?: string;
+        nullable?: boolean;
+    };
+    params: SqlRoutineParamDef[];
+    ignoreSchemaChanges?: RoutineIgnoreField[];
+}
+/** Resolved parameter of a stored routine for schema operations. */
+export interface SqlRoutineParamDef {
+    name: string;
+    type: string;
+    direction: 'in' | 'out' | 'inout';
+    nullable?: boolean;
+    defaultRaw?: string;
+}
+export interface TablePartition {
+    name: string;
+    schema?: string;
+    bound: string;
+}
+export interface TablePartitioning {
+    definition: string;
+    partitions: TablePartition[];
+}
 export interface ColumnDifference {
     oldColumnName: string;
     column: Column;
@@ -127,6 +171,10 @@ export interface ColumnDifference {
 export interface TableDifference {
     name: string;
     changedComment?: string;
+    changedPartitioning?: {
+        from?: TablePartitioning;
+        to?: TablePartitioning;
+    };
     fromTable: DatabaseTable;
     toTable: DatabaseTable;
     addedColumns: Dictionary<Column>;
@@ -174,6 +222,12 @@ export interface SchemaDifference {
         to: DatabaseView;
     }>;
     removedViews: Dictionary<DatabaseView>;
+    newRoutines: Dictionary<SqlRoutineDef>;
+    changedRoutines: Dictionary<{
+        from: SqlRoutineDef;
+        to: SqlRoutineDef;
+    }>;
+    removedRoutines: Dictionary<SqlRoutineDef>;
     removedNamespaces: Set<string>;
     removedNativeEnums: {
         name: string;
@@ -246,7 +300,7 @@ export interface ICriteriaNode<T extends object> {
     shouldInline(payload: any): boolean;
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
-    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string, options?: ICriteriaNodeProcessOptions): string;
     getPath(opts?: {
         addIndex?: boolean;
     }): string;
@@ -343,7 +397,7 @@ type ClassEntityColumns<T, TOptions extends MikroKyselyPluginOptions = {}> = T e
 type ClassEntityColumnName<K, V, TOptions extends MikroKyselyPluginOptions = {}> = K extends symbol ? never : NonNullable<V> extends infer NV ? NV extends {
     [k: number]: any;
     readonly owner: object;
-} ? never : TOptions['columnNamingStrategy'] extends 'property' ? K : NV extends Scalar ? K extends string ? SnakeCase<K> : never : K extends string ? ClassEntityJoinColumnName<SnakeCase<K>, NV> : never : never;
+} ? never : TOptions['columnNamingStrategy'] extends 'property' ? K : NV extends Scalar | readonly any[] ? K extends string ? SnakeCase<K> : never : K extends string ? ClassEntityJoinColumnName<SnakeCase<K>, NV> : never : never;
 type ClassEntityJoinColumnName<TName extends string, V> = PrimaryProperty<V> extends string ? `${TName}_${SnakeCase<PrimaryProperty<V>>}` : never;
-type ClassEntityColumnValue<V> = NonNullable<V> extends Scalar ? V : Primary<NonNullable<V>>;
+type ClassEntityColumnValue<V> = NonNullable<V> extends Scalar | readonly any[] ? V : Primary<NonNullable<V>>;
 export {};