Function getFieldExtraAttributes

src/lib/dbml/dbml-import/dbml-import.ts:438–516

(
            field: Field,
            enums: DBMLEnum[]
        )

        const allEnums: DBMLEnum[] = [];

        const getFieldExtraAttributes = (
            field: Field,
            enums: DBMLEnum[]
        ): Partial<DBMLField> => {
            // First check if the type name itself contains the length (e.g., "character varying(50)")
            const typeName = field.type.type_name;
            let extractedArgs: string[] | undefined;

            // Check for types with embedded length like "character varying(50)" or varchar(255)
            const typeWithLengthMatch = typeName.match(/^(.+?)\(([^)]+)\)$/);
            if (typeWithLengthMatch) {
                // Extract the args from the type name itself
                extractedArgs = typeWithLengthMatch[2]
                    .split(',')
                    .map((arg: string) => arg.trim());
            }

            // Use extracted args or fall back to field.type.args
            const args =
                extractedArgs ||
                (field.type.args ? field.type.args.split(',') : undefined);

            if (!args || args.length === 0) {
                return {};
            }

            const dataType = mapDBMLTypeToDataType(field.type.type_name, {
                ...options,
                enums,
            });

            // Also check the preferred synonym for field attributes (e.g., decimal → numeric)
            const preferredType = options.databaseType
                ? getPreferredSynonym(dataType.name, options.databaseType)
                : null;
            const effectiveType = preferredType ?? dataType;

            // Check if this is a character type that should have a max length
            const baseTypeName = typeName
                .replace(/\(.*\)/, '')
                .toLowerCase()
                .replace(/['"]/g, '');
            const isCharType =
                baseTypeName.includes('char') ||
                baseTypeName.includes('varchar') ||
                baseTypeName === 'text' ||
                baseTypeName === 'string';

            if (isCharType && args[0]) {
                return {
                    characterMaximumLength: args[0],
                };
            } else if (
                effectiveType.fieldAttributes?.precision &&
                effectiveType.fieldAttributes?.scale
            ) {
                const precisionNum = args?.[0] ? parseInt(args[0]) : undefined;
                const scaleNum = args?.[1] ? parseInt(args[1]) : undefined;