n8n-io/n8n · critical · DataTypeNotSupportedError

Data type "${type}" in "${column.entityMetadata.targetName}.

Error message

Data type "${type}" in "${column.entityMetadata.targetName}.${column.propertyName}" is not supported by "${database}" database.

What it means

Thrown by EntityMetadataValidator.validate via DataTypeNotSupportedError when a non-virtual @Column's normalized type is not present in driver.supportedDataTypes for the configured database. The validator filters out virtual properties, calls driver.normalizeType(column), and if indexOf === -1 throws naming the type, the entity.property, and the database.

Source

Thrown at packages/@n8n/typeorm/src/metadata-builder/EntityMetadataValidator.ts:114

			if (sameDiscriminatorValueEntityMetadata)
				throw new TypeORMError(
					`Entities ${entityMetadata.name} and ${sameDiscriminatorValueEntityMetadata.name} have the same discriminator values. Make sure they are different while using the @ChildEntity decorator.`,
				);
		}

		entityMetadata.relationCounts.forEach((relationCount) => {
			if (relationCount.relation.isManyToOne || relationCount.relation.isOneToOne)
				throw new TypeORMError(
					`Relation count can not be implemented on ManyToOne or OneToOne relations.`,
				);
		});

		entityMetadata.columns
			.filter((column) => !column.isVirtualProperty)
			.forEach((column) => {
				const normalizedColumn = driver.normalizeType(column) as ColumnType;
				if (driver.supportedDataTypes.indexOf(normalizedColumn) === -1)
					throw new DataTypeNotSupportedError(column, normalizedColumn, driver.options.type);
				if (column.length && driver.withLengthColumnTypes.indexOf(normalizedColumn) === -1)
					throw new TypeORMError(
						`Column ${column.propertyName} of Entity ${entityMetadata.name} does not support length property.`,
					);
				if (column.type === 'enum' && !column.enum && !column.enumName)
					throw new TypeORMError(
						`Column "${column.propertyName}" of Entity "${entityMetadata.name}" is defined as enum, but missing "enum" or "enumName" properties.`,
					);
			});

		// Postgres supports only STORED generated columns.
		if (driver.options.type === 'postgres') {
			const virtualColumn = entityMetadata.columns.find(
				(column) =>
					column.asExpression && (!column.generatedType || column.generatedType === 'VIRTUAL'),
			);
			if (virtualColumn)
				throw new TypeORMError(

View on GitHub (pinned to 5ac6606e81)

Solutions

Replace the column type with one present in driver.supportedDataTypes for your database (consult the TypeORM column-types table).
For driver-specific features, use a typed @Column with the canonical TypeORM alias (e.g. 'simple-array', 'json', 'uuid').
Keep test-suite entities on types supported by every driver you target in CI.

Example fix

// before (on sqlite)
@Column({ type: 'hstore' }) metadata: Record<string, string>;

// after
@Column({ type: 'simple-json' }) metadata: Record<string, string>;

Defensive patterns

Strategy: validation

Validate before calling

function assertColumnTypesSupported(dataSource: DataSource): string[] {
  const supported = new Set(dataSource.driver.supportedDataTypes as string[]);
  const problems: string[] = [];
  for (const meta of dataSource.entityMetadatas) {
    for (const col of meta.columns.filter((c) => !c.isVirtualProperty)) {
      const norm = dataSource.driver.normalizeType(col) as string;
      if (!supported.has(norm)) {
        problems.push(`${meta.targetName}.${col.propertyName} type '${norm}' not supported by ${dataSource.options.type}`);
      }
    }
  }
  return problems;
}

Try / catch

try {
  await dataSource.initialize();
} catch (err) {
  if (err.message.includes('is not supported by') && err.message.includes('database')) {
    // swap the column type for one in driver.supportedDataTypes
  }
  throw err;
}

Prevention

Pin entity column types to the canonical TypeORM aliases present in supportedDataTypes for every driver you target.
Boot a DataSource per driver in CI so unsupported types fail the build, not staging.
Keep driver-specific types behind feature flags or per-driver entity overrides.

When it happens

Trigger: Declaring a column with a type the active driver cannot map (e.g. 'hstore' on sqlite, 'mediumint' on postgres, an enum-array type on a driver that does not support it).

Common situations: Switching the database type (sqlite <-> postgres <-> mysql) without auditing column types; copying an entity from a MySQL project into a SQLite test setup; using a driver-specific type name that does not match TypeORM's normalized set.

Related errors

AI-assisted analysis of n8n-io/n8n@5ac6606e81 (2026-08-12). Data as JSON: /api/errors/3251a9ef31bf80fe. Report an issue: GitHub.