hcengineering/platform · error

Unsupported type: ${property.type} ${currentPath}

Error message

Unsupported type: ${property.type} ${currentPath}

What it means

Thrown by CardsProcessor.convertPropertyType when a card property declares a type name that has no mapping to a core Huly type. The switch handles a fixed set (e.g. TypeBoolean, TypeString, etc.); any unrecognized string — typo, unsupported type, or type from another plugin — lands in the default case.

Source

Thrown at packages/importer/src/huly/cards.ts:495

              of: baseType
            }
          : baseType
    } else {
      switch (property.type) {
        case 'TypeString':
          type._class = core.class.TypeString
          type.label = core.string.String
          break
        case 'TypeNumber':
          type._class = core.class.TypeNumber
          type.label = core.string.Number
          break
        case 'TypeBoolean':
          type._class = core.class.TypeBoolean
          type.label = core.string.Boolean
          break
        default:
          throw new Error('Unsupported type: ' + property.type + ' ' + currentPath)
      }
    }
    return type
  }

  private async createCardWithRelations (
    cardHeader: Record<string, any>,
    cardPath: string,
    masterTagId: Ref<MasterTag>,
    masterTagAssociaions: Map<string, AssociationMetadata>,
    masterTagAttributes: Map<string, UnifiedDoc<Attribute<MasterTag>>>,
    blobFiles: Map<string, UnifiedFile>,
    parentCardId?: Ref<Card>
  ): Promise<UnifiedDoc<Doc>[]> {
    const { _class, title, blobs: rawBlobs, tags: rawTags, ...customProperties } = cardHeader
    const tags = rawTags !== undefined ? (Array.isArray(rawTags) ? rawTags : [rawTags]) : []

    const tagAttributes = new Map<string, UnifiedDoc<Attribute<Tag>>>()

View on GitHub (pinned to 63e28dc964)

Solutions

1. Replace the property `type:` value with one supported by the importer's switch (e.g. TypeString, TypeBoolean, TypeNumber, etc.).
2. Check the importer source for the exact set of supported type case labels and use one verbatim.
3. If the type genuinely doesn't exist, add a case to convertPropertyType mapping it to the appropriate core class.

Example fix

# before
properties:
  deadline:
    type: TypeDatetime
# after
properties:
  deadline:
    type: TypeTimestamp

const SUPPORTED_PROPERTY_TYPES = ['TypeString', 'TypeNumber', 'TypeBoolean', 'TypeTimestamp', 'TypeRef'] // match importer's switch
function validatePropertyTypes(def: { properties: Record<string, { type: string }> }): string[] {
  return Object.entries(def.properties)
    .filter(([, p]) => !SUPPORTED_PROPERTY_TYPES.includes(p.type))
    .map(([k]) => k)
}

function isSupportedPropertyType(t: string): t is 'TypeString' | 'TypeNumber' | 'TypeBoolean' | 'TypeTimestamp' {
  return ['TypeString', 'TypeNumber', 'TypeBoolean', 'TypeTimestamp'].includes(t)
}

try {
  await processor.type(propDef, currentPath)
} catch (e) {
  if (e instanceof Error && e.message.startsWith('Unsupported type:')) {
    const badType = e.message.split(' ')[2]
    console.error(`Property type '${badType}' is not mapped — use one of the importer's supported type names`)
  } else throw e
}

When it happens

Trigger: Declaring a custom property in a card/master-tag YAML with `type:` set to an unmapped name (e.g. `TypeDatetime` when only `TypeTimestamp` is supported, or a custom plugin type) while processing via the `type` flow.

Common situations: Copy-pasting type names from other Huly plugins; inventing intuitive names not in the importer's mapping table; importer version that lacks a newly introduced core type.

Related errors

• Unsupported card type: ${cardType} in ${cardPath}
• Invalid master tag data
• Invalid tag data
• Unsupported attribute type: ${baseType._class}
• Invalid workspace: \n${errors}

AI-assisted analysis of hcengineering/platform@63e28dc964 (2026-08-29). Data as JSON: /api/errors/cd068515bdb0713f. Report an issue: GitHub.