@mikro-orm/sql 7.0.0-dev.99 → 7.0.0-rc.1

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { DeferMode, CheckCallback, Dictionary, EntityProperty, GroupOperator, RawQueryFragment, QBFilterQuery, QueryOrderMap, Type, QueryFlag, AnyEntity, EntityName, EntitySchemaWithMeta, Primary, PrimaryProperty, Opt } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, FilterQuery, GroupOperator, IndexColumnOptions, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, 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';
@@ -11,8 +11,8 @@ export interface Table {
     schema_name?: string;
     table_comment?: string;
 }
-type AnyString = string & {};
-export type Field<T> = AnyString | keyof T | RawQueryFragment | QueryBuilder | NativeQueryBuilder;
+/** @internal */
+export type InternalField<T> = string | RawQueryFragment | QueryBuilder | NativeQueryBuilder;
 export interface JoinOptions {
     table: string;
     schema?: string;
@@ -78,6 +78,29 @@ export interface IndexDef {
         predicate?: string;
     }>;
     deferMode?: DeferMode | `${DeferMode}`;
+    /**
+     * Advanced column options for the index.
+     * When specified, these options override the simple columnNames for index generation.
+     */
+    columns?: IndexColumnOptions[];
+    /**
+     * Columns to include in the index but not as part of the key (PostgreSQL, MSSQL).
+     */
+    include?: string[];
+    /** Fill factor for the index as a percentage 0-100 (PostgreSQL, MSSQL). */
+    fillFactor?: number;
+    /**
+     * Whether the index is invisible/hidden from the query optimizer (MySQL 8+, MariaDB 10.6+, MongoDB).
+     */
+    invisible?: boolean;
+    /**
+     * Whether the index is disabled (MSSQL only).
+     */
+    disabled?: boolean;
+    /**
+     * Whether the index should be clustered (MariaDB, MSSQL).
+     */
+    clustered?: boolean;
 }
 export interface CheckDef<T = unknown> {
     name: string;
@@ -111,6 +134,15 @@ export interface TableDifference {
     changedForeignKeys: Dictionary<ForeignKey>;
     removedForeignKeys: Dictionary<ForeignKey>;
 }
+export interface DatabaseView {
+    name: string;
+    schema?: string;
+    definition: string;
+    /** True if this is a materialized view (PostgreSQL only). */
+    materialized?: boolean;
+    /** For materialized views, whether data was populated on creation. */
+    withData?: boolean;
+}
 export interface SchemaDifference {
     newNamespaces: Set<string>;
     newNativeEnums: {
@@ -121,6 +153,12 @@ export interface SchemaDifference {
     newTables: Dictionary<DatabaseTable>;
     changedTables: Dictionary<TableDifference>;
     removedTables: Dictionary<DatabaseTable>;
+    newViews: Dictionary<DatabaseView>;
+    changedViews: Dictionary<{
+        from: DatabaseView;
+        to: DatabaseView;
+    }>;
+    removedViews: Dictionary<DatabaseView>;
     removedNamespaces: Set<string>;
     removedNativeEnums: {
         name: string;
@@ -132,54 +170,54 @@ export interface SchemaDifference {
 export interface IQueryBuilder<T> {
     readonly alias: string;
     readonly type: QueryType;
-    _fields?: Field<T>[];
+    /** @internal */
+    _fields?: InternalField<T>[];
     /** @internal */
     helper: any;
-    select(fields: Field<T> | Field<T>[], distinct?: boolean): this;
+    select(fields: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;
     addSelect(fields: string | string[]): this;
-    from<T extends AnyEntity<T> = AnyEntity>(target: EntityName<T> | IQueryBuilder<T>, aliasName?: string): IQueryBuilder<T>;
+    from<T extends object>(target: EntityName<T> | IQueryBuilder<T>, aliasName?: string): IQueryBuilder<T>;
     insert(data: any): this;
     update(data: any): this;
-    delete(cond?: QBFilterQuery): this;
+    delete(cond?: FilterQuery<any>): this;
     truncate(): this;
     count(field?: string | string[], distinct?: boolean): this;
-    join(field: string, alias: string, cond?: QBFilterQuery, type?: JoinType, path?: string): this;
-    innerJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    leftJoin(field: string, alias: string, cond?: QBFilterQuery): this;
-    joinAndSelect(field: string, alias: string, cond?: QBFilterQuery): this;
-    leftJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
-    innerJoinAndSelect(field: string, alias: string, cond?: QBFilterQuery, fields?: string[]): this;
+    join(field: string, alias: string, cond?: FilterQuery<any>, type?: JoinType, path?: string): this;
+    innerJoin(field: string, alias: string, cond?: FilterQuery<any>): this;
+    leftJoin(field: string, alias: string, cond?: FilterQuery<any>): this;
+    joinAndSelect(field: any, alias: string, cond?: FilterQuery<any>): this;
+    leftJoinAndSelect(field: any, alias: string, cond?: FilterQuery<any>, fields?: string[]): this;
+    innerJoinAndSelect(field: any, alias: string, cond?: FilterQuery<any>, fields?: string[]): this;
     withSubQuery(subQuery: RawQueryFragment | NativeQueryBuilder, alias: string): this;
-    where(cond: QBFilterQuery<T>, operator?: keyof typeof GroupOperator): this;
-    where(cond: string, params?: any[], operator?: keyof typeof GroupOperator): this;
-    andWhere(cond: QBFilterQuery<T>): this;
-    andWhere(cond: string, params?: any[]): this;
-    orWhere(cond: QBFilterQuery<T>): this;
-    orWhere(cond: string, params?: any[]): this;
+    where(cond: FilterQuery<T> | string | RawQueryFragment | Dictionary, operator?: keyof typeof GroupOperator | any[], operator2?: keyof typeof GroupOperator): this;
+    andWhere(cond: FilterQuery<T> | string | RawQueryFragment | Dictionary, params?: any[]): this;
+    orWhere(cond: FilterQuery<T> | string | RawQueryFragment | Dictionary, params?: any[]): this;
     orderBy(orderBy: QueryOrderMap<T>): this;
     groupBy(fields: (string | keyof T) | (string | keyof T)[]): this;
-    having(cond?: QBFilterQuery | string, params?: any[]): this;
+    having(cond?: FilterQuery<any> | string, params?: any[]): this;
     getAliasForJoinPath(path: string, options?: ICriteriaNodeProcessOptions): string | undefined;
     getJoinForPath(path?: string, options?: ICriteriaNodeProcessOptions): JoinOptions | undefined;
-    getNextAlias(entityName?: string): string;
-    clone(reset?: boolean): IQueryBuilder<T>;
+    getNextAlias(entityName?: string | EntityName<T>): string;
+    clone(reset?: boolean | string[], preserve?: string[]): IQueryBuilder<T>;
     setFlag(flag: QueryFlag): this;
     unsetFlag(flag: QueryFlag): this;
     hasFlag(flag: QueryFlag): boolean;
     scheduleFilterCheck(path: string): void;
+    withSchema(schema: string): this;
 }
 export interface ICriteriaNodeProcessOptions {
     alias?: string;
     matchPopulateJoins?: boolean;
     ignoreBranching?: boolean;
     preferNoBranch?: boolean;
-    type?: 'orderBy';
+    type?: 'orderBy' | 'having';
     filter?: boolean;
+    parentPath?: string;
 }
 export interface ICriteriaNode<T extends object> {
-    readonly entityName: string;
+    readonly entityName: EntityName<T>;
     readonly parent?: ICriteriaNode<T> | undefined;
-    readonly key?: string | undefined;
+    readonly key?: string | symbol | undefined;
     readonly strict?: boolean;
     payload: any;
     prop?: EntityProperty;
@@ -189,23 +227,23 @@ export interface ICriteriaNode<T extends object> {
     willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
     shouldRename(payload: any): boolean;
     renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
-    getPath(addIndex?: boolean): string;
+    getPath(opts?: {
+        addIndex?: boolean;
+    }): string;
     getPivotPath(path: string): string;
 }
 export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
 export type InferEntityProperties<Schema> = Schema extends EntitySchemaWithMeta<any, any, any, any, infer Properties> ? Properties : never;
 export type InferKyselyDB<TEntities extends {
     name: string;
-}, TOptions extends MikroKyselyPluginOptions = {}> = MapValueAsTable<MapByName<TEntities>, TOptions>;
+}, TOptions extends MikroKyselyPluginOptions = {}> = MapValueAsTable<MapTableName<TEntities, TOptions>, TOptions>;
 export type InferDBFromKysely<TKysely extends Kysely<any>> = TKysely extends Kysely<infer TDB> ? TDB : never;
-type PreferStringLiteral<TCandidate, TFallback> = [
-    TCandidate
-] extends [never] ? TFallback : string extends TCandidate ? TFallback : TCandidate extends string ? TCandidate : TFallback;
-export type MapByName<T extends {
+type PreferStringLiteral<TCandidate, TFallback> = [TCandidate] extends [never] ? TFallback : string extends TCandidate ? TFallback : TCandidate extends string ? TCandidate : TFallback;
+export type MapTableName<T extends {
     name: string;
     tableName?: string;
-}> = {
-    [P in T as PreferStringLiteral<NonNullable<P['tableName']>, P['name']>]: P;
+}, TOptions extends MikroKyselyPluginOptions = {}> = {
+    [P in T as TOptions['tableNamingStrategy'] extends 'entity' ? P['name'] : PreferStringLiteral<NonNullable<P['tableName']>, P['name']>]: P;
 };
 export type MapValueAsTable<TMap extends Record<string, any>, TOptions extends MikroKyselyPluginOptions = {}> = {
     [K in keyof TMap as TransformName<K, TOptions['tableNamingStrategy'] extends 'entity' ? 'entity' : 'underscore'>]: InferKyselyTable<TMap[K], TOptions>;
@@ -235,7 +273,9 @@ type MaybeJoinColumnName<TName extends string, TBuilder> = TBuilder extends {
         owner: true;
     };
 } ? PrimaryProperty<Value> extends string ? `${TName}_${SnakeCase<PrimaryProperty<Value>>}` : never : TName;
-export type SnakeCase<TName extends string> = TName extends `${infer P1}${infer P2}` ? P2 extends Uncapitalize<P2> ? `${Uncapitalize<P1>}${SnakeCase<P2>}` : `${Uncapitalize<P1>}_${SnakeCase<Uncapitalize<P2>>}` : TName;
+export type SnakeCase<TName extends string> = TName extends `${infer A}${infer B}${infer Rest}` ? IsUpperLetter<B> extends never ? `${Lowercase<A>}${SnakeCase<`${B}${Rest}`>}` : IsLowerLetter<A> extends never ? `${Lowercase<A>}${SnakeCase<`${B}${Rest}`>}` : `${Lowercase<A>}_${SnakeCase<`${B}${Rest}`>}` : Lowercase<TName>;
+type IsLowerLetter<C extends string> = C extends Lowercase<C> ? (C extends Uppercase<C> ? never : C) : never;
+type IsUpperLetter<C extends string> = C extends Uppercase<C> ? (C extends Lowercase<C> ? never : C) : never;
 type InferColumnValue<TBuilder, TProcessOnCreate extends boolean> = TBuilder extends {
     '~type'?: {
         value: infer Value;
@@ -244,7 +284,7 @@ type InferColumnValue<TBuilder, TProcessOnCreate extends boolean> = TBuilder ext
 } ? MaybeNever<MaybeGenerated<MaybeJoinKey<Value, TOptions>, TOptions, TProcessOnCreate>, TOptions> : never;
 type MaybeGenerated<TValue, TOptions, TProcessOnCreate extends boolean> = TOptions extends {
     nullable: true;
-} ? (TValue | null) : TOptions extends {
+} ? TValue | null : TOptions extends {
     autoincrement: true;
 } ? Generated<TValue> : TOptions extends {
     default: true;
@@ -262,9 +302,9 @@ type MaybeJoinKey<TValue, TOptions> = TOptions extends {
 } ? UnwrapOpt<Primary<TValue>> : never : TValue;
 type UnwrapOpt<TValue> = TValue extends Opt<infer OriginalValue> ? OriginalValue : TValue;
 type MaybeNever<TValue, TOptions> = TOptions extends {
-    persist: true;
-} ? never : TOptions extends {
-    kind: 'm:n';
+    persist: false;
+} | {
+    kind: 'm:n' | '1:m';
 } ? never : TValue;
 type ExcludeNever<TMap extends Record<string, any>> = {
     [K in keyof TMap as TMap[K] extends never ? never : K]: TMap[K];

package/dialects/postgresql/PostgreSqlTableCompiler.d.ts

@@ -1 +0,0 @@
-export {};

package/dialects/postgresql/PostgreSqlTableCompiler.js

@@ -1 +0,0 @@
-export {};