src/driver/react-native/ReactNativeDriver.ts (1)

898-903: Minor: Consider clarifying JSDoc wording.

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.

 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

src/driver/mongodb/MongoDriver.ts (1)

486-491: Minor: Consider clarifying JSDoc wording.

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.

 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

docs/docs/advanced-topics/3-indices.md (1)

147-155: Optional: Consider enhancing the documentation example.

The documentation is clear, but the example could be more comprehensive by showing:

1. All available index types (btree, hash, gist, spgist, gin, brin)
2. Usage with column names for multi-column indices
3. Combination with other options like unique or concurrent

 ## Index Type
 If you need to specify a custom type for the index, you can use the `type` property. If the `spatial` property is set, this field will be ignored.
 
 ```typescript
+// Single column with index type
 @Index({ type: 'hash' })
+@Column()
+email: string
+
+// Multi-column index with type
+@Index(['firstName', 'lastName'], { type: 'btree' })
+
+// Available types: 'btree', 'hash', 'gist', 'spgist', 'gin', 'brin'

This feature is currently supported only for PostgreSQL.

</blockquote></details>
<details>
<summary>src/driver/oracle/OracleDriver.ts (1)</summary><blockquote>

`945-950`: **Minor: Consider clarifying JSDoc wording.**

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.



```diff
 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

src/driver/sqlserver/SqlServerDriver.ts (1)

940-945: Minor: Consider clarifying JSDoc wording.

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.

 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

src/driver/cockroachdb/CockroachDriver.ts (1)

981-986: Minor: Consider clarifying JSDoc wording.

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.

 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

src/driver/spanner/SpannerDriver.ts (1)

713-718: Minor: Consider clarifying JSDoc wording.

The JSDoc says "supports type indices" but "index types" might be more grammatically precise and consistent with the feature name.

 /**
- * Returns true if driver supports type indices
+ * Returns true if driver supports index types
  */
 isIndicesTypeSupported(): boolean {
     return false
 }

src/decorator/options/IndexOptions.ts (1)

69-74: Clarify documented literals for type to match TableIndexTypes

The new type?: TableIndexTypes option and PostgreSQL-only note look good. To reduce ambiguity, consider mentioning the actual string literals ("btree", "hash", "gist", "spgist", "gin", "brin") in the comment so it’s obvious that values are lowercase and match TableIndexTypes.

src/driver/mysql/MysqlDriver.ts (1)

1166-1171: MySQL index-type capability correctly disabled; tweak comment wording

Returning false from isIndicesTypeSupported() is appropriate so MySQL is excluded from PostgreSQL-style index types and can be gated centrally. You might optionally rephrase the comment to “Returns true if driver supports index types” for slightly clearer wording.

src/metadata-args/IndexMetadataArgs.ts (1)

89-94: Align type documentation with concrete string values

The new type?: TableIndexTypes field and PostgreSQL-only note are appropriate. As a small clarity improvement, consider explicitly listing the accepted lowercase string values ("btree", "hash", "gist", "spgist", "gin", "brin") so consumers don’t have to look up TableIndexTypes to know the valid inputs.

src/driver/sap/SapDriver.ts (1)

862-867: SAP HANA: index-type capability correctly marked unsupported

Having isIndicesTypeSupported() return false is consistent with this driver’s current feature set and lets schema-building logic uniformly gate use of the type option. As with the MySQL driver, you might optionally rename the comment to “supports index types” for slightly clearer phrasing.

src/schema-builder/RdbmsSchemaBuilder.ts (1)

1016-1026: Good guard for unsupported drivers; consider tightening the check slightly

The preflight in createNewIndices cleanly prevents creating indices with type on drivers that do not support index types, which matches the new error behavior in dropOldIndices.

Two small polish suggestions:

• Use .some to clarify intent (boolean existence check rather than retrieving the first element):

-            if (
-                newIndices.find(
-                    (idx) =>
-                        !!idx.type &&
-                        !this.connection.driver.isIndicesTypeSupported(),
-                )
-            ) {
+            if (
+                newIndices.some(
+                    (idx) =>
+                        idx.type &&
+                        !this.connection.driver.isIndicesTypeSupported(),
+                )
+            ) {

• Optionally mention the index name in the error message to help users pinpoint the offending index.

Both are non-blocking; current logic is functionally correct.

src/driver/postgres/PostgresDriver.ts (1)

31-32: Index type support and comparison logic for Postgres look solid

The isIndicesTypeSupported() flag and compareTableIndexTypes implementation are consistent with Postgres semantics:

• Defaulting missing types to "btree" aligns with PostgreSQL’s default index method.
• Treating isSpatial as "gist" preserves legacy behavior while still allowing explicit type: "gist".
• Case-insensitive comparison correctly handles any casing from metadata or introspection.

You might optionally tweak the JSDoc to say “index types” instead of “type indices,” but behavior-wise this is ready to go.

Also applies to: 1444-1449, 1464-1469

src/metadata/IndexMetadata.ts (1)

7-8: type metadata wiring is correct; consider updating the isSpatial comment

The new type?: TableIndexTypes field and its propagation in the constructor integrate cleanly with the rest of the schema/index pipeline, and the change:

this.isSpatial =
    !!options.args.spatial || options.args.type === "gist"

nicely ensures that @Index({ type: "gist" }) behaves as a spatial index as expected in Postgres.

One minor nit: the JSDoc above isSpatial still says “Works only in MySQL.” Given this new behavior, it would be clearer to mention that isSpatial is also used to drive GiST index handling in Postgres.

Also applies to: 123-129, 158-160, 170-171

src/driver/postgres/PostgresQueryRunner.ts (1)

4349-4373: Make buildIndexTypeClause more robust and slightly clearer

The helper is a good place to centralize validation and prevent index‑type injection. A couple of small tweaks would make it more ergonomic and defensive:

• Treat index types case‑insensitively (so "GiST" etc. don’t fail even if passed from JS consumers).
• Include the offending type in the error message for easier debugging.
• Minor: use const for the Set and avoid reusing the type variable name for the normalized form.

For example:

-    private buildIndexTypeClause(index: TableIndex) {
-        // List of index types supported by PostgreSQL
-        // https://www.postgresql.org/docs/current/indexes-types.html
-        let pgValidIdxTypes = new Set<string>([
-            "btree",
-            "hash",
-            "gist",
-            "spgist",
-            "gin",
-            "brin",
-        ])
-
-        let type = index.isSpatial ? "gist" : index.type
-
-        if (typeof type !== "string") return null
-
-        if (!pgValidIdxTypes.has(type))
-            throw new TypeORMError(`Unsupported index type`)
-
-        return `USING ${type}`
-    }
+    private buildIndexTypeClause(index: TableIndex) {
+        // List of index types supported by PostgreSQL
+        // https://www.postgresql.org/docs/current/indexes-types.html
+        const pgValidIdxTypes = new Set<string>([
+            "btree",
+            "hash",
+            "gist",
+            "spgist",
+            "gin",
+            "brin",
+        ])
+
+        const rawType = index.isSpatial ? "gist" : index.type
+        if (typeof rawType !== "string") return null
+
+        const type = rawType.toLowerCase()
+
+        if (!pgValidIdxTypes.has(type)) {
+            throw new TypeORMError(
+                `Unsupported index type "${rawType}" for PostgreSQL`,
+            )
+        }
+
+        return `USING ${type}`
+    }

You might also consider reusing buildIndexTypeClause from createViewIndexSql in a follow‑up if you decide to support explicit types on view indices as well.

Also applies to: 4379-4389

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: alumni
Repo: typeorm/typeorm PR: 11581
File: docs/docs/drivers/postgres.md:23-23
Timestamp: 2025-07-27T20:50:10.364Z
Learning: The correct data source type for Aurora PostgreSQL in TypeORM is `aurora-postgres`, not `aurora-data-api-pg`. The `aurora-data-api-pg` driver was renamed to `aurora-postgres` according to the CHANGELOG.md. This is defined in the DatabaseType union type and AuroraPostgresConnectionOptions interface.

Learnt from: ZBAGI
Repo: typeorm/typeorm PR: 11724
File: test/functional/schema-builder/entity/react-native/Post.ts:0-0
Timestamp: 2025-10-16T19:19:25.146Z
Learning: In TypeORM tests, react-native uses SQLite as its underlying database, not MySQL or MariaDB. SQLite treats double quotes as identifier quotes, making them appropriate for CHECK constraints and other SQL expressions in react-native entity files.

Learnt from: alumni
Repo: typeorm/typeorm PR: 11581
File: docs/docs/drivers/postgres.md:23-23
Timestamp: 2025-07-27T20:50:10.364Z
Learning: The correct data source type for Aurora PostgreSQL in TypeORM is `aurora-postgres`, not `aurora-data-api-pg`. The `aurora-data-api-pg` driver was renamed to `aurora-postgres` according to the CHANGELOG.md. This is defined in the DatabaseType union type and AuroraPostgresConnectionOptions interface.

Learnt from: alumni
Repo: typeorm/typeorm PR: 11576
File: src/data-source/DataSource.ts:542-546
Timestamp: 2025-08-16T18:51:14.170Z
Learning: When improving type safety in TypeORM's query execution chain, adding generics to the QueryRunner.query method allows for proper type propagation from DataSource.query<T> through to QueryResult<T>, eliminating the need for type casts like 'as any' and 'as T'.

Learnt from: alumni
Repo: typeorm/typeorm PR: 11581
File: docs/docs/drivers/mongodb.md:9-13
Timestamp: 2025-07-27T17:29:18.547Z
Learning: TypeORM supports MongoDB driver versions "^5.8.0 || ^6.0.0" according to the peerDependencies in package.json. The v4 driver is NOT supported. Always check package.json for accurate peer dependency information.

Learnt from: alumni
Repo: typeorm/typeorm PR: 11581
File: docs/docs/drivers/mongodb.md:9-13
Timestamp: 2025-07-27T17:29:18.547Z
Learning: TypeORM is compatible only with mongodb@^6, not v4 as previously suggested. The package.json file contains the authoritative peer dependency information for the MongoDB driver version compatibility.